chore: bump version to 0.5.0 (14) (#1081)

* docs: draft DroidDeck 0.5.0 release notes

* docs: expand DroidDeck 0.5.0 release notes

* docs: complete 0.5.0 contributor credits

* docs: update the 0.5.0 release notes for everything merged so far, with screenshots and GIFs

Adds the x86-64 Steam client, Linux games under FEX, app-wide glasses tracking, store-game artwork and Adjust logo, and the merged Epic launcher and XR glasses entries. Media is in docs/releases/media/0.5.0.

---------

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

.gitattributes

@@ -2,3 +2,11 @@ tools/linuxfs/** text=auto eol=lf
 tools/mangoapp/** text=auto eol=lf
 tools/comet/LICENSE whitespace=-blank-at-eof
 tools/comet/droiddeck.patch whitespace=-blank-at-eol,-blank-at-eof
+
+# These helpers are packaged verbatim and executed inside the Linux runtime.
+tools/linuxfs/overlay/** text eol=lf
+tools/linuxfs/desktop/** text eol=lf
+tools/mangoapp/mangoapp text eol=lf
+app/src/main/assets/desktop-removal/*.json text eol=lf
+app/src/main/assets/desktop-removal/*.txt text eol=lf
+*.pdf binary

.github/workflows/build-fex.yml

@@ -0,0 +1,49 @@
+name: Build FEX (x86-64 Steam client)
+
+# Checks tools/fex: the same build DroidDeck-Components' build-fex.yml runs from this repository to publish FEX
+# (its single `fex` release and fex.json, which the app follows). Nothing is published from here.
+
+on:
+  push:
+    paths:
+      - 'tools/fex/**'
+      - '.github/workflows/build-fex.yml'
+  workflow_dispatch:
+    inputs:
+      thunks:
+        description: 'Build the host thunks (Vulkan/GL/X11/... to the runtime arm64 libraries)'
+        required: false
+        default: 'false'
+      cxxflags:
+        description: 'Extra CXXFLAGS for a diagnostic build (e.g. -DDEBUG_STRACE)'
+        required: false
+        default: ''
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04-arm
+    timeout-minutes: 120
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - name: Build in Arch Linux ARM
+        # Inputs reach the shell as environment variables, never pasted into the script.
+        env:
+          FEX_EXTRA_CXXFLAGS: ${{ inputs.cxxflags }}
+          FEX_THUNKS: ${{ inputs.thunks == 'true' && '1' || '0' }}
+        run: |
+          set -euo pipefail
+          docker run --rm -e FEX_EXTRA_CXXFLAGS="$FEX_EXTRA_CXXFLAGS" -e FEX_THUNKS="$FEX_THUNKS" -v "$PWD:/work" -w /work menci/archlinuxarm:base-devel bash tools/fex/build-in-arch.sh
+          sudo chown -R "$(id -u):$(id -g)" .
+      - uses: actions/upload-artifact@v4
+        with:
+          name: fex
+          path: |
+            fex.tzst
+            fex.tzst.sha256
+            fex-needed.txt
+            fex-files.txt

.github/workflows/build.yml

@@ -26,7 +26,7 @@ concurrency:
   cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 
 env:
-  PRELOAD_CACHE_VERSION: v3
+  PRELOAD_CACHE_VERSION: v6
 
 jobs:
   build:
@@ -313,9 +313,15 @@ jobs:
           set -euo pipefail
           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
-            DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends gcc g++ gcc-multilib g++-multilib binutils >/dev/null
+            install_compilers() {
+              apt-get -o Acquire::Check-Valid-Until=false update -qq &&
+                DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends gcc g++ gcc-multilib g++-multilib binutils >/dev/null
+            }
+            printf "deb http://deb.debian.org/debian bullseye main\ndeb http://security.debian.org/debian-security bullseye-security main\n" > /etc/apt/sources.list
+            if ! install_compilers; then
+              printf "deb http://archive.debian.org/debian bullseye main\ndeb http://archive.debian.org/debian-security bullseye-security main\n" > /etc/apt/sources.list
+              install_compilers
+            fi
             tools/linuxfs/build-x86-preloads.sh app/src/main/assets/linuxfs
           '
           sudo chown -R "$(id -u):$(id -g)" app/src/main/assets/linuxfs
@@ -398,6 +404,12 @@ jobs:
 
       - name: Check Quest tracking IPC
         run: |
+          set -euo pipefail
+          NDK="${ANDROID_NDK_LATEST_HOME:-${ANDROID_NDK_HOME:-$ANDROID_NDK_ROOT}}"
+          VK_INCLUDE=$(ls -d "$NDK"/toolchains/llvm/prebuilt/*/sysroot/usr/include | head -1)
+          mkdir -p build/vr/include
+          cp -R "$VK_INCLUDE/vulkan" build/vr/include/
+          if [ -d "$VK_INCLUDE/vk_video" ]; then cp -R "$VK_INCLUDE/vk_video" build/vr/include/; fi
           g++ -std=c++17 -Wall -Wextra -Werror -pthread tools/vr/tests/test_xr_tracking.cpp -o /tmp/test-xr-tracking
           /tmp/test-xr-tracking
           g++ -std=c++17 -Wall -Wextra -Werror tools/vr/tests/test_xr_touch.cpp -o /tmp/test-xr-touch
@@ -500,7 +512,24 @@ jobs:
         run: python3 -m unittest discover -s tools/tests -p 'test_*.py'
 
       - name: Unit tests
-        run: ./gradlew testReleaseUnitTest --console=plain -PndkVersion="$NDK_VERSION"
+        id: unit-tests
+        run: |
+          set -o pipefail
+          mkdir -p app/build
+          ./gradlew testReleaseUnitTest --console=plain --info --stacktrace -Drobolectric.logging=stderr -PndkVersion="$NDK_VERSION" 2>&1 | tee app/build/unit-tests.log
+
+      - name: Upload unit test diagnostics
+        id: unit-test-diagnostics
+        if: always() && steps.unit-tests.outcome != 'skipped'
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-results
+          path: |
+            app/build/unit-tests.log
+            app/build/test-results/testReleaseUnitTest/
+            app/build/reports/tests/testReleaseUnitTest/
+          if-no-files-found: ignore
+          retention-days: 14
 
       - name: Sign with the testkey (v1 + v2 + v3)
         run: |
@@ -530,6 +559,15 @@ jobs:
           grep -qi "CN=Android, OU=Android, O=Android" /tmp/sig.txt \
             || { echo "::error::apk is not signed with the AOSP testkey"; exit 1; }
 
+      - uses: actions/upload-artifact@v4
+        id: apk-upload
+        with:
+          name: droiddeck-apk
+          path: app/build/outputs/apk/release/*.apk
+          if-no-files-found: error
+          retention-days: 30
+          compression-level: 0
+
       - name: Report on the pull request
         if: always() && github.event_name == 'pull_request'
         continue-on-error: true
@@ -538,6 +576,9 @@ jobs:
           PR: ${{ github.event.pull_request.number }}
           RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
           BUILD_OUTCOME: ${{ steps.build.outcome }}
+          UNIT_TEST_OUTCOME: ${{ steps.unit-tests.outcome }}
+          TEST_DIAGNOSTICS_URL: ${{ steps.unit-test-diagnostics.outputs.artifact-url }}
+          APK_OUTCOME: ${{ steps.apk-upload.outcome }}
           SAME_REPO: ${{ github.event.pull_request.head.repo.full_name == github.repository }}
         run: |
           set -uo pipefail
@@ -548,8 +589,8 @@ jobs:
             echo
             [ -f /tmp/pr-merge.md ] && cat /tmp/pr-merge.md
             echo
-            case "$BUILD_OUTCOME" in
-              success)
+            case "$BUILD_OUTCOME:$UNIT_TEST_OUTCOME:$APK_OUTCOME" in
+              success:success:success)
                 echo "###  Build passed"
                 echo
                 echo "The \`droiddeck-apk\` artifact is [on this run]($RUN_URL), signed with the public test key."
@@ -562,7 +603,28 @@ jobs:
                 echo
                 echo "Fallback: [open **PR Release Publish**]($GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/workflows/pr-release-publish.yml) on \`main\` and enter PR \`$PR\`."
                 ;;
-              failure)
+              success:success:*)
+                echo "###  APK publication incomplete"
+                echo
+                echo "Compilation and unit tests passed, but APK publication did not complete. See [the run]($RUN_URL)."
+                ;;
+              success:failure:*)
+                echo "### ERROR: Unit tests failed"
+                echo
+                echo "The APK compiled, but unit tests failed. No installable artifact was published."
+                echo
+                if [ -n "$TEST_DIAGNOSTICS_URL" ]; then
+                  echo "The [unit-test-results]($TEST_DIAGNOSTICS_URL) artifact contains the test log and any generated reports."
+                else
+                  echo "The test diagnostics upload did not complete. See [the test log]($RUN_URL)."
+                fi
+                ;;
+              success:*)
+                echo "###  Build incomplete"
+                echo
+                echo "The APK compiled, but unit tests did not complete successfully. See [the run]($RUN_URL)."
+                ;;
+              failure:*)
                 echo "### ERROR: Build failed"
                 echo
                 echo "The compiler's errors ([full log]($RUN_URL)):"
@@ -580,7 +642,7 @@ jobs:
                 echo '```'
                 echo "</details>"
                 ;;
-              skipped|cancelled)
+              skipped:*|cancelled:*)
                 echo "###  Not built"
                 echo
                 echo "The build did not run (see above, or [the run]($RUN_URL))."
@@ -596,14 +658,6 @@ jobs:
             gh api -X POST "repos/${GITHUB_REPOSITORY}/issues/${PR}/comments" -F body=@/tmp/pr-report.md >/dev/null
           fi
 
-      - uses: actions/upload-artifact@v4
-        with:
-          name: droiddeck-apk
-          path: app/build/outputs/apk/release/*.apk
-          if-no-files-found: error
-          retention-days: 30
-          compression-level: 0
-
   sign:
     needs: build
     if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main'

README.md

@@ -15,10 +15,14 @@ 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). 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.
+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 and downloads games into the Games storage. Epic keeps its direct API install path. Opening Epic Stores prepares Epic’s official Linux launcher preview. When installed, Epic games launched from DroidDeck use that client, and games installed in the client are imported into DroidDeck’s library and shortcuts. The x86-64 client runs through FEX on ARM and DroidDeck retains its Proton hooks; this preview and ARM setup are outside Epic’s listed Linux support. The cog on a store’s chip row sets its opening tab and download speed tier.
 
 On Android 14 and newer, before Steam launches, you must turn on **Disable child process restrictions** 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.
 
+## Smart glasses
+
+Use **Setup → Smart glasses** for app-wide virtual-screen settings across DroidDeck menus, launchers, desktop sessions, and games. Supported VITURE, RayNeo, and XREAL connections provide 3DoF; Luma Ultra adds optional experimental 6DoF and stereo-assisted hand/Joy-Con tracking. Model support and SDK requirements differ: see the [smart-glasses support matrix](docs/smart-glasses-support.md) for supported devices, controls, setup, and limitations.
+
 ## 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 zip from **Share logs** (Setup, or the session drawer) so the logs come with it.
@@ -29,6 +33,12 @@ Run `tools/build_local.sh` with Docker, Java 17, the Android SDK/NDK, Rust throu
 
 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.
 
+For the prepared Windows checkout, run `./tools/run_windows.ps1` (optionally with `-Serial <adb-serial>`), or select **DroidDeck XR** in Android Studio and run the **app** module on the connected phone. Machine-specific options live in the ignored `local.properties`: `droiddeck.python` selects a Python executable, `droiddeck.skipRust=true` omits the optional store download engines, and `droiddeck.debugApplicationIdSuffix=.xr` installs **DroidDeck XR Dev** alongside the signed release. The development app has its own runtime and Steam login. The local Java selection is in `.gradle/config.properties`.
+
+`python tools/prepare_windows_runtime.py` restores this checkout's audited runtime inputs from the pinned CI APK, three locally rebuilt preload libraries, and the checksum-pinned Gamescope archive in `build/windows-setup/`. Start Docker Desktop's Linux engine first: preparation now rebuilds DroidDeck's ARM64 VR driver and Vulkan layer from current source and runs their native regression tests. The compiler image is built automatically on first use. Vulkan headers come from the NDK beside `--llvm-strip`, or from an explicit `--vk-include <NDK-sysroot-include>` directory.
+
+To reuse that build, pass `--rebuilt-vr build/windows-setup/vr`. Preparation verifies its `vr-build.json` against the current Git revision, source files, Vulkan headers, output checksums, and ARM64 architecture; missing or stale builds fail instead of falling back to the donor's VR libraries. The script checks the actual donor CI merge tree, still rejects unrelated unaudited runtime changes, and records component provenance in `app/build/windows-runtime-provenance.json`. Preserve these ignored preparation files when rebuilding locally; `clean` removes the prepared assets and their verification manifest.
+
 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
@@ -37,4 +47,10 @@ Compatibility and performance vary by device; hardware validation is limited. De
 
 ## Credits and licence
 
-GPL-3.0. Runtime, shim, input, and controller work build on WinNative and Bannerlator (maxjivi05). Epic Games and GOG support build on [Phobos’s](https://github.com/phobos665) adaptation of [Legendary](https://github.com/legendary-gl/legendary) and [gogdl](https://github.com/Heroic-Games-Launcher/heroic-gogdl), respectively. LSFG frame generation is from the work of Camille LaVey and the [Eden](https://eden-emu.dev) emulator project, following [lsfg-vk](https://github.com/PancakeTAS/lsfg-vk), ported to WinNative and DroidDeck by [@maxjivi05](https://github.com/maxjivi05); it needs your own copy of [Lossless Scaling](https://store.steampowered.com/app/993090/) and ships none of its shaders. x86 AppImages, and any whose own runtime cannot unpack them, are unpacked with [uruntime](https://github.com/VHSgunzo/uruntime) by VHSgunzo (MIT), shipped unmodified with its licence. See [LICENSE](LICENSE). Steam and Proton belong to Valve Corporation; this project is not affiliated with Valve.
+GPL-3.0. Runtime, shim, input, and controller work build on WinNative and Bannerlator (maxjivi05). Epic Games and GOG support build on [Phobos’s](https://github.com/phobos665) adaptation of [Legendary](https://github.com/legendary-gl/legendary) and [gogdl](https://github.com/Heroic-Games-Launcher/heroic-gogdl), respectively. LSFG frame generation is from the work of Camille LaVey and the [Eden](https://eden-emu.dev) emulator project, following [lsfg-vk](https://github.com/PancakeTAS/lsfg-vk), ported to WinNative and DroidDeck by [@maxjivi05](https://github.com/maxjivi05); it needs your own copy of [Lossless Scaling](https://store.steampowered.com/app/993090/) and ships none of its shaders. x86 AppImages, and any whose own runtime cannot unpack them, are unpacked with [uruntime](https://github.com/VHSgunzo/uruntime) by VHSgunzo (MIT), shipped unmodified with its licence. mmap ring-buffer controller input was developed by ribbit384 ([WinNative #345](https://github.com/WinNative-Emu/WinNative/pull/345)). See [LICENSE](LICENSE). Steam and Proton belong to Valve Corporation; this project is not affiliated with Valve.
+
+XR glasses support builds on WinNative's VITURE glasses work. VITURE protocol details were checked against [XRLinuxDriver](https://github.com/wheaney/XRLinuxDriver) by [@wheaney](https://github.com/wheaney), including the VITURE protocol header it ships, [ar-drivers-rs](https://github.com/badicsalex/ar-drivers-rs) by [@badicsalex](https://github.com/badicsalex) and the [go-macos/iokit VITURE package](https://pkg.go.dev/github.com/go-macos/iokit/viture); the optional VITURE SDK belongs to VITURE and is not included. RayNeo support adapts [@informalTechCode](https://github.com/informalTechCode)'s [RayNeo-Air-Series-3DoF-Scaffold](https://github.com/informalTechCode/RayNeo-Air-Series-3DoF-Scaffold) (Apache-2.0) and references [@verncat](https://github.com/verncat)'s [RayNeo-Air-3S-Pro-OpenVR](https://github.com/verncat/RayNeo-Air-3S-Pro-OpenVR) (MIT) and [Monado](https://gitlab.freedesktop.org/monado/monado) (BSL-1.0); see [docs/third-party/rayneo](docs/third-party/rayneo/README.md). XREAL 1S support references [XRLinuxDriver](https://github.com/wheaney/XRLinuxDriver) and [xrealOneDeviceKit](https://github.com/wheaney/xrealOneDeviceKit) by @wheaney, [xreal_one_driver](https://github.com/rohitsangwan01/xreal_one_driver) by [@rohitsangwan01](https://github.com/rohitsangwan01) (MIT) and [xr-tools](https://github.com/0xcaff/xr-tools) by [@0xcaff](https://github.com/0xcaff). The REDMAGIC glasses-display findings draw on [@mekhontsev](https://github.com/mekhontsev)'s [MagicDesk investigation](https://github.com/mekhontsev/magicdesk/blob/main/docs/xr-resolution-fix.md) and [@Coding-BR](https://github.com/Coding-BR)'s [decompiled Nubia kernel](https://github.com/Coding-BR/android_kernel_nubia_sm8850_qwjujube). VITURE, RayNeo, XREAL and REDMAGIC are trademarks of their owners; this project is not affiliated with them.
+
+Joy-Con VR controllers port the arm model of Google's [Google VR SDK for Unity](https://github.com/googlevr/gvr-unity-sdk) (Apache-2.0), adapt the hand skeleton of Valve's [OpenVR](https://github.com/ValveSoftware/openvr) `handskeletonsimulation` sample (BSD-3-Clause), which follows Moshi Turner's hand simulation in [Monado](https://gitlab.freedesktop.org/monado/monado), and use the Index controller offsets from Monado's `vive_poses.c` (BSL-1.0). Joy-Con behaviour was researched in Linux's [hid-nintendo](https://github.com/torvalds/linux/blob/master/drivers/hid/hid-nintendo.c) driver by Daniel J. Ogorchock, [@dekuNukem](https://github.com/dekuNukem)'s [Nintendo_Switch_Reverse_Engineering](https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering), [SDL](https://github.com/libsdl-org/SDL) and the Android Open Source Project, and checked against [ALVR](https://github.com/alvr-org/ALVR), [OpenComposite](https://gitlab.com/znixian/OpenOVR), [PSMoveSteamVRBridge](https://github.com/HipsterSloth/PSMoveSteamVRBridge), [@F8LEFT](https://github.com/F8LEFT)'s [JoyConVr](https://github.com/F8LEFT/JoyConVr), [@krnelpan1c](https://github.com/krnelpan1c)'s [Daydream-Controller-SteamVR](https://github.com/krnelpan1c/Daydream-Controller-SteamVR), [@yoyobuae](https://github.com/yoyobuae)'s [joyconvr](https://github.com/yoyobuae/joyconvr), [Moonlight](https://github.com/moonlight-stream/moonlight-android) and [Dolphin](https://github.com/dolphin-emu/dolphin); see [docs/third-party/joycon](docs/third-party/joycon/README.md). Nintendo Switch and Joy-Con are trademarks of Nintendo; this project is not affiliated with Nintendo.
+
+Camera hand tracking runs Google's [MediaPipe](https://github.com/google-ai-edge/mediapipe) Tasks Vision library with its Pose Landmarker (Lite) model, BlazePose GHUM 3D, and its Hand Landmarker model (all Apache-2.0), on frames from AndroidX [CameraX](https://developer.android.com/jetpack/androidx/releases/camera) (Apache-2.0); MediaPipe's usage reports are switched off. The design was checked against [@F8LEFT](https://github.com/F8LEFT)'s [JoyConVr](https://github.com/F8LEFT/JoyConVr) camera app (MIT), and the short Joy-Con movements follow the accelerometer mode of the [Google VR SDK for Unity](https://github.com/googlevr/gvr-unity-sdk)'s arm model, Eric Foxlin's zero-velocity updates and Frosio, Pedersini and Borghese's accelerometer autocalibration, and the camera and Joy-Con are joined by a Kalman filter (R. E. Kalman, 1960). Bare camera hands take their gestures after [ALVR](https://github.com/alvr-org/ALVR)'s `hand_gestures.rs` (MIT) and Meta Quest's menu pinch, with distances checked on photos from the [HaGRID](https://github.com/hukenovs/hagrid) gesture set (CC BY-SA 4.0, not included), fit the palm with Horn's quaternion method (1987) and smooth it with the 1€ filter (Casiez, Roussel and Vogel, 2012); the white glove model follows Valve's OpenVR render model reference and Index controller poses, is meshed with surface nets (Gibson, 1998; Mikola Lysenko) and blends and shades it with Inigo Quilez's smooth minimum and distance-field ambient occlusion, porting his polygon distance (MIT); see [docs/third-party/handtracking](docs/third-party/handtracking/README.md).

app/build.gradle

@@ -4,6 +4,32 @@ plugins {
 apply plugin: 'kotlin-android'
 apply plugin: 'org.jetbrains.kotlin.plugin.compose'
 
+// Machine-specific tooling and optional CI-prepared inputs stay out of version control.
+def localBuildOptions = new Properties()
+def localBuildOptionsFile = rootProject.layout.projectDirectory.file('local.properties')
+if (localBuildOptionsFile.asFile.exists()) {
+    localBuildOptions.load(new StringReader(providers.fileContents(localBuildOptionsFile).asText.get()))
+}
+def pythonExecutable = project.findProperty('pythonExecutable')
+    ?: localBuildOptions.getProperty('droiddeck.python', 'python3')
+def vitureSdkDir = project.hasProperty('vitureSdkDir') ? project.property('vitureSdkDir') : localBuildOptions.getProperty('droiddeck.vitureSdk', '')
+def uvcDir = project.hasProperty('uvcDir') ? project.property('uvcDir') : localBuildOptions.getProperty('droiddeck.uvcDir', '')
+if (uvcDir) {
+    ['arm64-v8a/libusb.so', 'arm64-v8a/libuvc.a', 'include/libusb.h', 'include/libuvc/libuvc.h',
+     'licenses/libusb-COPYING', 'licenses/libuvc-LICENSE.txt'].each { required ->
+        if (!new File(uvcDir, required).isFile()) throw new GradleException("Incomplete UVC build: missing ${required}")
+    }
+}
+if (vitureSdkDir) {
+    ['android/arm64-v8a/libglasses.so', 'android/arm64-v8a/libcarina_vio.so',
+     'android/arm64-v8a/libcloud_protocol.so', 'include/viture_glasses_provider.h',
+     'android/LICENSE', 'android/NOTICE'].each { required ->
+        if (!new File(vitureSdkDir, required).isFile()) {
+            throw new GradleException("Incomplete VITURE Android SDK: missing ${required}")
+        }
+    }
+}
+
 def gitValue = { List<String> arguments ->
     try {
         def output = providers.exec {
@@ -79,8 +105,8 @@ android {
         applicationId "com.droiddeck.launcher"
         minSdkVersion 26
         targetSdkVersion 28
-        versionCode 13
-        versionName "0.4.0"
+        versionCode 14
+        versionName "0.5.0"
         buildConfigField "String", "BUILD_LABEL", "\"${escapedBuildLabel}\""
         buildConfigField "String", "SOURCE_COMMIT", "\"${sourceCommit}\""
         buildConfigField "int", "PR_NUMBER", "${prNumber}"
@@ -100,6 +126,8 @@ android {
         externalNativeBuild {
             cmake {
                 arguments '-DANDROID_STL=c++_shared'
+                arguments "-DDROIDDECK_VITURE_SDK_DIR=${vitureSdkDir.toString().replace('\\', '/')}"
+                arguments "-DDROIDDECK_UVC_DIR=${uvcDir.toString().replace('\\', '/')}"
             }
         }
     }
@@ -128,6 +156,11 @@ android {
         debug {
             minifyEnabled false
             signingConfig signingConfigs.testkey
+            def localSuffix = localBuildOptions.getProperty('droiddeck.debugApplicationIdSuffix')
+            if (localSuffix) {
+                applicationIdSuffix localSuffix
+                resValue 'string', 'app_name', 'DroidDeck XR Dev'
+            }
         }
         release {
             minifyEnabled false
@@ -158,6 +191,10 @@ android {
     testOptions {
         unitTests.returnDefaultValues = true
         unitTests.includeAndroidResources = true
+        unitTests.all {
+            def logTarget = providers.systemProperty('robolectric.logging').orNull
+            if (logTarget != null) systemProperty 'robolectric.logging', logTarget
+        }
     }
 
     compileOptions {
@@ -169,6 +206,16 @@ android {
     }
 }
 
+// Vendor binaries remain in the user's SDK directory; never vendor them into Git.
+if (vitureSdkDir) {
+    android.sourceSets.main.jniLibs.srcDir(new File(vitureSdkDir, 'android'))
+    def stageVitureNotices = tasks.register('stageVitureNotices', Copy) {
+        from(new File(vitureSdkDir, 'android')) { include 'LICENSE', 'NOTICE' }
+        into(layout.buildDirectory.dir('vitureAssets/licenses/viture'))
+    }
+    tasks.named('preBuild').configure { dependsOn(stageVitureNotices) }
+}
+
 def stageSessionScripts = tasks.register('stageSessionScripts', Copy) {
     from(rootProject.file('tools/linuxfs/overlay')) {
         include 'usr/local/bin/droiddeck-*', 'usr/local/bin/steam-compatibility', 'usr/bin/**'
@@ -185,12 +232,21 @@ def stageRuntimeAssets = tasks.register('stageRuntimeAssets', Sync) {
     into(runtimeAssetsDir)
 }
 android.sourceSets.main.assets.setSrcDirs([runtimeAssetsDir])
+if (vitureSdkDir) android.sourceSets.main.assets.srcDir(layout.buildDirectory.dir('vitureAssets'))
+if (uvcDir) {
+    def stageUvcNotices = tasks.register('stageUvcNotices', Copy) {
+        from(new File(uvcDir, 'licenses'))
+        into(layout.buildDirectory.dir('uvcAssets/licenses/uvc'))
+    }
+    tasks.named('preBuild').configure { dependsOn(stageUvcNotices) }
+    android.sourceSets.main.assets.srcDir(layout.buildDirectory.dir('uvcAssets'))
+}
 tasks.named('preBuild').configure { dependsOn(stageRuntimeAssets) }
 
 def verifyRuntimeInputs = tasks.register('verifyRuntimeInputs', Exec) {
     mustRunAfter(stageSessionScripts, stageRuntimeAssets)
     workingDir rootProject.projectDir
-    commandLine 'python3', 'tools/release/runtime_inputs.py', 'verify'
+    commandLine pythonExecutable, 'tools/release/runtime_inputs.py', 'verify'
 }
 tasks.configureEach { task ->
     if (task.name in ['packageDebug', 'packageRelease']) task.dependsOn(verifyRuntimeInputs)
@@ -198,7 +254,8 @@ tasks.configureEach { task ->
 
 def rustCrateDir = layout.projectDirectory.dir('src/main/rust/stores')
 def rustJniLibsDir = layout.buildDirectory.dir('rustJniLibs')
-def skipRust = (project.findProperty('skipRust') ?: 'false').toString().toBoolean()
+def skipRust = (project.findProperty('skipRust')
+    ?: localBuildOptions.getProperty('droiddeck.skipRust', 'false')).toString().toBoolean()
 def buildRustStores = tasks.register('buildRustStores', Exec) {
     description = 'Cross-compiles the store download engines (libdroiddeckstores.so) with cargo-ndk.'
     onlyIf { !skipRust }
@@ -225,9 +282,24 @@ def buildRustStores = tasks.register('buildRustStores', Exec) {
 if (!skipRust) android.sourceSets.main.jniLibs.srcDir(rustJniLibsDir)
 tasks.named('preBuild').configure { dependsOn(buildRustStores) }
 
+def verifyHandModel = tasks.register('verifyHandModel') {
+    def models = ['hand_landmarker.task': 'fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1',
+                  'hand_landmarker_lite.task': '173c0f47ecee7e935bd4a1e93aa580756b4180c1307c07d709313e82c28672c8']
+        .collectEntries { name, hash -> [(file("src/main/assets/models/$name")): hash] }
+    inputs.files(models.keySet())
+    doLast {
+        models.each { model, expected ->
+            def actual = java.security.MessageDigest.getInstance('SHA-256').digest(model.bytes).encodeHex().toString()
+            if (actual != expected) throw new GradleException("Hand Landmarker model checksum mismatch: ${model.name}")
+        }
+    }
+}
+tasks.named('preBuild').configure { dependsOn(verifyHandModel) }
+
 dependencies {
+    implementation 'org.opencv:opencv:4.13.0'
     implementation 'org.khronos.openxr:openxr_loader_for_android:1.1.49'
-    implementation 'com.github.luben:zstd-jni:1.5.2-3@aar'
+    implementation 'com.github.luben:zstd-jni:1.5.7-4@aar'
     implementation 'org.apache.commons:commons-compress:1.27.1'
     implementation 'org.tukaani:xz:1.10'
     implementation platform('androidx.compose:compose-bom:2024.02.00')
@@ -242,9 +314,14 @@ dependencies {
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
     implementation 'com.flyfishxu:kadb-android:1.2.1'
     implementation 'com.termux.termux-app:terminal-view:0.118.0'
+    implementation 'androidx.camera:camera-camera2:1.4.2'
+    implementation 'androidx.camera:camera-lifecycle:1.4.2'
+    implementation('com.google.mediapipe:tasks-vision:1.0.0') {
+        exclude group: 'com.google.auto.value', module: 'auto-value'
+    }
 
     testImplementation 'junit:junit:4.13.2'
     testImplementation 'org.robolectric:robolectric:4.16.1'
     testImplementation 'androidx.compose.ui:ui-test-junit4'
-    testRuntimeOnly 'com.github.luben:zstd-jni:1.5.2-3@jar'
+    testRuntimeOnly 'com.github.luben:zstd-jni:1.5.7-4@jar'
 }

app/src/main/AndroidManifest.xml

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
 
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE" />
@@ -19,14 +20,19 @@
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
     <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
     <uses-permission android:name="android.permission.BLUETOOTH" />
+    <uses-permission android:name="android.permission.CAMERA" />
 
     <uses-feature android:name="android.hardware.vulkan.version" android:version="0x401000" android:required="true" />
     <uses-feature android:name="android.hardware.gamepad" android:required="false" />
+    <uses-feature android:name="android.hardware.camera" android:required="false" />
+    <uses-feature android:name="android.hardware.camera.front" android:required="false" />
+    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false" />
     <uses-feature android:name="android.hardware.vr.headtracking" android:version="1" android:required="false" />
 
     <application
         android:name=".App"
         android:localeConfig="@xml/locales_config"
+        android:networkSecurityConfig="@xml/network_security_config"
         android:allowBackup="false"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
@@ -38,6 +44,9 @@
         android:isGame="true">
 
         <meta-data android:name="android.game_mode_config" android:resource="@xml/game_mode_config" />
+        <service android:name=".glasses.LumaRgbCaptureService" android:exported="false"
+            android:process=":rgb_diagnostic" />
+        <meta-data android:name="com.oculus.supportedDevices" android:value="quest2|quest3|quest3s" />
         <activity android:name=".QuestXrActivity" android:exported="true" android:launchMode="singleTask"
             android:permission="android.permission.DUMP"
             android:resizeableActivity="false" android:screenOrientation="landscape"
@@ -59,11 +68,13 @@
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
+                <category android:name="android.intent.category.CAR_LAUNCHER" />
             </intent-filter>
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
                 <category android:name="android.intent.category.DEFAULT" />
                 <category android:name="android.intent.category.BROWSABLE" />
+                <category android:name="android.intent.category.CAR_LAUNCHER" />
                 <data android:scheme="droiddeck" android:host="game" />
             </intent-filter>
             <intent-filter>
@@ -73,6 +84,7 @@
             <intent-filter>
                 <action android:name="com.droiddeck.launcher.LAUNCH_GAME" />
                 <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.CAR_LAUNCHER" />
             </intent-filter>
         </activity>
 
@@ -119,7 +131,7 @@
             android:name=".stores.StoreLoginActivity"
             android:exported="false"
             android:screenOrientation="sensorLandscape"
-            android:configChanges="orientation|screenSize|screenLayout|smallestScreenSize"
+            android:configChanges="orientation|screenSize|screenLayout|smallestScreenSize|density"
             android:theme="@style/AppTheme" />
 
         <activity
@@ -141,6 +153,16 @@
             android:resizeableActivity="true"
             android:configChanges="orientation|screenSize|screenLayout|smallestScreenSize|keyboard|keyboardHidden|navigation|uiMode|density" />
 
+        <activity
+            android:name=".gpu.SteamVrRestartActivity"
+            android:exported="false"
+            android:process=":vr_recovery"
+            android:taskAffinity="${applicationId}.vr_recovery"
+            android:excludeFromRecents="true"
+            android:screenOrientation="sensorLandscape"
+            android:configChanges="orientation|screenSize|screenLayout|smallestScreenSize|keyboard|keyboardHidden|navigation|uiMode|density"
+            android:theme="@style/SessionTheme" />
+
         <service
             android:name=".session.SessionService"
             android:exported="false"
@@ -180,5 +202,13 @@
             android:exported="true"
             android:permission="android.permission.DUMP"
             android:grantUriPermissions="false" />
+        <activity android:name=".ui.SpatialTrackingActivity" android:exported="false" />
+        <service
+            android:name="com.google.android.datatransport.runtime.backends.TransportBackendDiscovery"
+            tools:node="merge">
+            <meta-data
+                android:name="backend:com.google.android.datatransport.cct.CctBackendFactory"
+                tools:node="remove" />
+        </service>
     </application>
 </manifest>

app/src/main/assets/calibration/luma-ultra-640x480.json

@@ -0,0 +1,102 @@
+{
+  "version": 1,
+  "identity": "luma-ultra-base-v1",
+  "width": 640,
+  "height": 480,
+  "fisheye": false,
+  "error": 1.1209395390660726,
+  "verified": false,
+  "k1": {
+    "rows": 3,
+    "cols": 3,
+    "data": [
+      226.0499636040297,
+      0,
+      321.62348950766386,
+      0,
+      228.36987999988767,
+      242.2674105020684,
+      0,
+      0,
+      1
+    ]
+  },
+  "d1": {
+    "rows": 5,
+    "cols": 1,
+    "data": [
+      -0.28622915867944043,
+      0.1194613930041054,
+      0.007984341063494766,
+      -0.0008220922923559441,
+      -0.025579805296512992
+    ]
+  },
+  "k2": {
+    "rows": 3,
+    "cols": 3,
+    "data": [
+      240.3338202496282,
+      0,
+      320.8790079027563,
+      0,
+      241.14047924325277,
+      260.45566640784716,
+      0,
+      0,
+      1
+    ]
+  },
+  "d2": {
+    "rows": 5,
+    "cols": 1,
+    "data": [
+      -0.27073208928390136,
+      0.08065508519805098,
+      -0.001460778493930769,
+      -0.0003694718992635806,
+      -0.011452505620454932
+    ]
+  },
+  "r": {
+    "rows": 3,
+    "cols": 3,
+    "data": [
+      0.900501479835182,
+      0.04473903344740378,
+      -0.43254537762047496,
+      -0.08255720039597626,
+      0.9941919046988283,
+      -0.06904176485356042,
+      0.4269442510181227,
+      0.0978819468416306,
+      0.8989648107712929
+    ]
+  },
+  "t": {
+    "rows": 3,
+    "cols": 1,
+    "data": [
+      -0.14117171913441395,
+      0.0014051874404824838,
+      -0.007555740272006347
+    ]
+  },
+  "cameraToHead": [
+    -0.05607918,
+    0.023585627,
+    -0.07998472,
+    0.01024512,
+    0.9945703,
+    0.005859665,
+    -0.10339546
+  ],
+  "deviceModel": "VITURE Luma Ultra",
+  "cameraPair": "left0-right0",
+  "sourceValidation": {
+    "exportDate": "2026-10-16",
+    "sourceDeviceVerified": true,
+    "capturedViews": 25,
+    "scope": "Starting geometry from one calibrated Luma Ultra; other units have not been individually validated."
+  }
+}

app/src/main/assets/models/hand_landmarker.provenance.json

@@ -0,0 +1,9 @@
+{
+  "url": "https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task",
+  "sha256": "fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1",
+  "bytes": 7819105,
+  "mediapipe": "com.google.mediapipe:tasks-vision:1.0.0",
+  "opencv": "org.opencv:opencv:4.13.0",
+  "documentation": "https://ai.google.dev/edge/mediapipe/solutions/vision/hand_landmarker",
+  "runtime": "Two video-mode instances; CPU default; GPU requires separate performance acceptance"
+}

app/src/main/assets/models/hand_landmarker_lite.provenance.json

@@ -0,0 +1,12 @@
+{
+  "sha256": "173c0f47ecee7e935bd4a1e93aa580756b4180c1307c07d709313e82c28672c8",
+  "composition": "Lite palm detector and lite hand landmarks with matching Tasks tensor metadata and associated files from the full bundle",
+  "palm_source": "https://storage.googleapis.com/mediapipe-assets/palm_detection_lite.tflite",
+  "palm_source_sha256": "e9a4aaddf90dda56a87235303cf00e4c2d3fb28725f68fd88772997dac905c18",
+  "landmark_source": "https://storage.googleapis.com/mediapipe-assets/hand_landmark_lite.tflite",
+  "landmark_source_sha256": "d7fde8ac11f8ce03f8663775bfc323f4fc9f2a38062b4f4efa142874ef5b2a48",
+  "metadata_source": "hand_landmarker.task",
+  "metadata_source_sha256": "fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1",
+  "builder": "tools/build_hand_lite.py; mediapipe==0.10.21; deterministic ZIP_STORED bundle and embedded associated-file archives",
+  "runtime": "com.google.mediapipe:tasks-vision:1.0.0; CPU by default; experimental stereo hand and wrist tracking"
+}

app/src/main/cpp/CMakeLists.txt

@@ -38,3 +38,24 @@ add_library(deviceinfo SHARED deviceinfo/vkinfo.c)
 target_link_libraries(deviceinfo dl)
 
 add_library(termux SHARED termux/termux.c)
+
+# The optional proprietary SDK is supplied locally; its headers/libraries are not vendored.
+if(DROIDDECK_VITURE_SDK_DIR)
+    add_library(droiddeck_viture SHARED viture/sdk_bridge.cpp)
+    target_compile_features(droiddeck_viture PRIVATE cxx_std_17)
+    target_include_directories(droiddeck_viture PRIVATE "${DROIDDECK_VITURE_SDK_DIR}/include")
+    target_link_directories(droiddeck_viture PRIVATE "${DROIDDECK_VITURE_SDK_DIR}/android/${ANDROID_ABI}")
+    target_link_libraries(droiddeck_viture PRIVATE glasses log)
+endif()
+
+if(DROIDDECK_UVC_DIR)
+    add_library(rgb_usb SHARED IMPORTED)
+    set_target_properties(rgb_usb PROPERTIES IMPORTED_LOCATION "${DROIDDECK_UVC_DIR}/${ANDROID_ABI}/libusb.so")
+    add_library(rgb_uvc STATIC IMPORTED)
+    set_target_properties(rgb_uvc PROPERTIES IMPORTED_LOCATION "${DROIDDECK_UVC_DIR}/${ANDROID_ABI}/libuvc.a")
+    add_library(droiddeck_uvc SHARED viture/uvc_bridge.cpp)
+    target_compile_features(droiddeck_uvc PRIVATE cxx_std_17)
+    target_include_directories(droiddeck_uvc PRIVATE "${DROIDDECK_UVC_DIR}/include")
+    target_link_libraries(droiddeck_uvc PRIVATE rgb_uvc rgb_usb log)
+    target_link_options(droiddeck_uvc PRIVATE -Wl,-z,max-page-size=16384)
+endif()

app/src/main/cpp/fakeinput_steam.cpp

@@ -75,7 +75,16 @@ static constexpr uint8_t GAMEPAD_AXIS_COUNT = 8;
 static constexpr uint8_t GAMEPAD_BUTTON_COUNT = 11;
 static constexpr uint32_t FAKE_INPUT_RING_MAGIC = 0x46494252;
 static constexpr uint32_t FAKE_INPUT_RING_VERSION = 2;
-static constexpr uint32_t FAKE_INPUT_EVENT_SIZE = sizeof(struct input_event);
+// Rings hold the 64-bit input_event layout that the arm64 writers use; 32-bit guests convert on read.
+struct RingEvent {
+  int64_t sec;
+  int64_t usec;
+  uint16_t type;
+  uint16_t code;
+  int32_t value;
+};
+static_assert(sizeof(RingEvent) == 24, "ring events must stay ABI-stable");
+static constexpr uint32_t FAKE_INPUT_EVENT_SIZE = sizeof(RingEvent);
 static constexpr uint32_t FAKE_INPUT_RING_CAPACITY = 4096;
 static constexpr unsigned int FAKE_INPUT_MAJOR = 13;
 static constexpr unsigned int FAKE_INPUT_EVENT_MINOR_BASE = 64;
@@ -371,6 +380,17 @@ send_vibration(int strong, int weak, uint16_t duration_ms, uint16_t slot) {
   syscall(SYS_close, sock);
 }
 
+// Must match RumbleComponent.HOLD_MS: play until the slot's next effect or stop.
+static constexpr uint16_t RUMBLE_HOLD_MS = 0xffff;
+
+__attribute__((visibility("hidden"))) static void send_ff_effect(const struct ff_effect &effect, uint16_t slot) {
+  uint16_t duration = effect.replay.length ? effect.replay.length : RUMBLE_HOLD_MS;
+  if (effect.type == FF_RUMBLE)
+    send_vibration(effect.u.rumble.strong_magnitude, effect.u.rumble.weak_magnitude, duration, slot);
+  else if (effect.type == FF_PERIODIC)
+    send_vibration(effect.u.periodic.magnitude, effect.u.periodic.magnitude, duration, slot);
+}
+
 __attribute__((visibility("hidden"))) static void
 check_ff_event(const struct input_event *ev, uint16_t slot) {
   if (ev->type != EV_FF)
@@ -381,15 +401,7 @@ check_ff_event(const struct input_event *ev, uint16_t slot) {
     auto it = ff_effects().find(id);
     if (it == ff_effects().end())
       return;
-
-    uint16_t duration = it->second.replay.length;
-    if (it->second.type == FF_RUMBLE) {
-      send_vibration(it->second.u.rumble.strong_magnitude,
-                     it->second.u.rumble.weak_magnitude, duration, slot);
-    } else if (it->second.type == FF_PERIODIC) {
-      send_vibration(it->second.u.periodic.magnitude,
-                     it->second.u.periodic.magnitude, duration, slot);
-    }
+    send_ff_effect(it->second, slot);
   } else {
     send_vibration(0, 0, 0, slot);
   }
@@ -925,14 +937,13 @@ __attribute__((visibility("hidden"))) static void flush_uinput(UinputWriter &w)
     return;
   }
   FakeInputRingHeader *ring = w.ring;
-  auto *events = reinterpret_cast<struct input_event *>(reinterpret_cast<uint8_t *>(ring) +
-                                                        FAKE_INPUT_RING_HEADER_SIZE);
+  auto *events = reinterpret_cast<RingEvent *>(reinterpret_cast<uint8_t *>(ring) +
+                                               FAKE_INPUT_RING_HEADER_SIZE);
   uint64_t write_seq = __atomic_load_n(&ring->write_seq, __ATOMIC_RELAXED);
   struct timeval now = {};
   gettimeofday(&now, nullptr);
-  for (struct input_event ev : w.pending) {
-    ev.time = now;
-    events[write_seq % FAKE_INPUT_RING_CAPACITY] = ev;
+  for (const struct input_event &ev : w.pending) {
+    events[write_seq % FAKE_INPUT_RING_CAPACITY] = {now.tv_sec, now.tv_usec, ev.type, ev.code, ev.value};
     write_seq++;
     if (ev.type == EV_KEY) {
       for (size_t i = 0; i < kSnapshotButtonCount; i++)
@@ -3469,16 +3480,7 @@ EXPORT int ioctl(int fd, ioctl_request_t op, ...) {
     if (effect->id == -1)
       effect->id = next_ff_id++;
     ff_effects()[effect->id] = *effect;
-
-    uint16_t duration = effect->replay.length;
-    uint16_t slot = static_cast<uint16_t>(event_number);
-    if (effect->type == FF_RUMBLE) {
-      send_vibration(effect->u.rumble.strong_magnitude,
-                     effect->u.rumble.weak_magnitude, duration, slot);
-    } else if (effect->type == FF_PERIODIC) {
-      send_vibration(effect->u.periodic.magnitude, effect->u.periodic.magnitude,
-                     duration, slot);
-    }
+    send_ff_effect(*effect, static_cast<uint16_t>(event_number));
     return 0;
   } else if (type == 0x45 && number == 0x81) {
     int id = (intptr_t)argp;
@@ -3517,6 +3519,12 @@ EXPORT int ioctl(int fd, ioctl_request_t op, ...) {
   } else if (type == 0x45 && number == 0x90) {
     Logger::log("Hooking ioctl EVIOCGRAB for event %s\n", event);
     return 0;
+  } else if (type == 0x6A && !strncmp(event, "event", 5)) {
+    // Older SDL2 builds treat any JSIOCGNAME answer as a joydev node and skip EVIOCGID, then drop the pad as 0000:0000.
+    Logger::log("Rejecting joydev ioctl %d for event %s\n", number, event);
+    guard.unlock();
+    errno = EINVAL;
+    return -1;
   } else if (type == 0x6A && number == 0x1) {
     Logger::log("Hooking ioctl JSIOCGVERSION for event %s\n", event);
     int version = JS_VERSION;
@@ -3579,7 +3587,7 @@ EXPORT ssize_t read(int fd, void *buf, size_t count) {
   }
   auto handle = controller->second;
   FakeController &fake = *handle;
-  if (count < FAKE_INPUT_EVENT_SIZE) {
+  if (count < sizeof(struct input_event)) {
     errno = EINVAL;
     return -1;
   }
@@ -3597,7 +3605,7 @@ EXPORT ssize_t read(int fd, void *buf, size_t count) {
       return -1;
     }
     for (int attempt = 0; attempt < 8; ++attempt) {
-      size_t requested = count / FAKE_INPUT_EVENT_SIZE;
+      size_t requested = count / sizeof(struct input_event);
       if (fake.keyframe_remaining == 0) {
         SnapshotState snap;
         if (!read_snapshot(fake.ring, snap)) break;
@@ -3616,17 +3624,22 @@ EXPORT ssize_t read(int fd, void *buf, size_t count) {
                                        FAKE_INPUT_RING_HEADER_SIZE;
           for (size_t i = 0; i < events; ++i) {
             size_t index = (fake.read_seq + i) % FAKE_INPUT_RING_CAPACITY;
-            struct input_event ev;
-            memcpy(&ev, ring_events + index * FAKE_INPUT_EVENT_SIZE, FAKE_INPUT_EVENT_SIZE);
+            RingEvent stored;
+            memcpy(&stored, ring_events + index * FAKE_INPUT_EVENT_SIZE, FAKE_INPUT_EVENT_SIZE);
+            struct input_event ev = {};
+            ev.time.tv_sec = stored.sec;
+            ev.time.tv_usec = stored.usec;
+            ev.type = stored.type;
+            ev.code = stored.code;
+            ev.value = stored.value;
             if (ev.type == EV_ABS) ev.code = presented_abs_code(fake, ev.code);
-            memcpy(static_cast<uint8_t *>(buf) + i * FAKE_INPUT_EVENT_SIZE, &ev,
-                   FAKE_INPUT_EVENT_SIZE);
+            memcpy(static_cast<uint8_t *>(buf) + i * sizeof(ev), &ev, sizeof(ev));
           }
           __atomic_thread_fence(__ATOMIC_ACQUIRE);
           if (snap.sequence != __atomic_load_n(&fake.ring->snapshot_seq, __ATOMIC_RELAXED))
             continue;
           fake.read_seq += events;
-          return static_cast<ssize_t>(events * FAKE_INPUT_EVENT_SIZE);
+          return static_cast<ssize_t>(events * sizeof(struct input_event));
         }
       }
 
@@ -3641,11 +3654,10 @@ EXPORT ssize_t read(int fd, void *buf, size_t count) {
         ev.code = kNeutralEvents[index].code;
         ev.value = keyframe_value(fake, ev.type, ev.code);
         if (ev.type == EV_ABS) ev.code = presented_abs_code(fake, ev.code);
-        memcpy(static_cast<uint8_t *>(buf) + i * FAKE_INPUT_EVENT_SIZE,
-               &ev, FAKE_INPUT_EVENT_SIZE);
+        memcpy(static_cast<uint8_t *>(buf) + i * sizeof(ev), &ev, sizeof(ev));
         --fake.keyframe_remaining;
       }
-      return static_cast<ssize_t>(events * FAKE_INPUT_EVENT_SIZE);
+      return static_cast<ssize_t>(events * sizeof(struct input_event));
     }
     if (nonblock) {
       errno = EAGAIN;

app/src/main/cpp/viture/display_modes.h

@@ -0,0 +1,36 @@
+#pragma once
+
+// Our controller uses the standard display-mode vocabulary, even for Beast.
+// Native mode reuses some numbers with different meanings; never pass them through.
+namespace droiddeck::viture {
+constexpr int to_native_mode(int standard) {
+    switch (standard) {
+        case 0x31: return 0x31; // 1080p 60
+        case 0x33: return 0x32; // 1080p 90
+        case 0x34: return 0x33; // 1080p 120
+        case 0x32: return 0x37; // 1080p SBS 60
+        case 0x35: return 0x38; // 1080p SBS 90
+        case 0x41: return 0x34; // 1200p 60
+        case 0x43: return 0x35; // 1200p 90
+        case 0x44: return 0x36; // 1200p 120
+        case 0x42: return 0x3a; // 1200p SBS 60
+        case 0x45: return 0x3b; // 1200p SBS 90
+        default: return -4;
+    }
+}
+constexpr int from_native_mode(int native) {
+    switch (native) {
+        case 0x31: return 0x31;
+        case 0x32: return 0x33;
+        case 0x33: return 0x34;
+        case 0x37: return 0x32;
+        case 0x38: return 0x35;
+        case 0x34: return 0x41;
+        case 0x35: return 0x43;
+        case 0x36: return 0x44;
+        case 0x3a: return 0x42;
+        case 0x3b: return 0x45;
+        default: return -4; // Ultrawide is not stereo.
+    }
+}
+}

app/src/main/cpp/viture/mjpeg_payload.h

@@ -0,0 +1,11 @@
+#pragma once
+#include <cstddef>
+#include <cstdint>
+
+inline std::size_t mjpeg_payload_size(const uint8_t* bytes, std::size_t size) {
+    if (!bytes || size < 4 || size > 4*1024*1024 || bytes[0] != 0xff || bytes[1] != 0xd8) return 0;
+    std::size_t end = size;
+    // Luma Ultra UVC frames can pad the JPEG to an eight-byte boundary with zeros.
+    while (end > 4 && size-end < 7 && bytes[end-1] == 0) --end;
+    return bytes[end-2] == 0xff && bytes[end-1] == 0xd9 ? end : 0;
+}

app/src/main/cpp/viture/sdk_bridge.cpp

@@ -0,0 +1,556 @@
+#include <jni.h>
+#include <android/log.h>
+#include <algorithm>
+#include <array>
+#include <vector>
+#include <deque>
+#include <cmath>
+#include <cstring>
+#include <cstdint>
+#include <memory>
+#include <mutex>
+#include <condition_variable>
+#include <chrono>
+#include <cstdio>
+#include <cstdlib>
+#include <cerrno>
+#include <string>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <linux/usbdevice_fs.h>
+#include <time.h>
+#include "viture_glasses_provider.h"
+#include "viture_device.h"
+#include "viture_device_carina.h"
+#include "viture_camera_provider.h"
+#include "viture_protocol_public.h"
+#include "viture_result.h"
+#include "viture_version.h"
+#include "display_modes.h"
+#include "stereo_frame_gate.h"
+
+namespace {
+// SDK callbacks have no user-data parameter. Only one provider may exist at a time.
+std::mutex api_mutex;
+std::mutex pose_mutex;
+std::array<float, 4> latest_pose{};
+int64_t latest_time = 0;
+bool accepting_pose = false;
+bool accepting_state = false;
+std::array<int, 6> state_values{};
+unsigned state_pending = 0;
+
+void on_state(int id, int value) {
+    std::lock_guard<std::mutex> lock(pose_mutex);
+    if (!accepting_state || id < 0 || id >= int(state_values.size())) return;
+    state_values[id] = value;
+    state_pending |= 1u << id;
+}
+
+void clear_state(bool accept) {
+    std::lock_guard<std::mutex> lock(pose_mutex);
+    accepting_state = accept;
+    state_pending = 0;
+}
+
+int64_t now_ns() {
+    timespec ts{};
+    clock_gettime(CLOCK_BOOTTIME, &ts);
+    return int64_t(ts.tv_sec) * 1000000000LL + ts.tv_nsec;
+}
+
+void on_pose(float* data, uint64_t) {
+    if (!data) return;
+    std::lock_guard<std::mutex> lock(pose_mutex);
+    if (!accepting_pose) return;
+    std::copy_n(data + 3, 4, latest_pose.begin());
+    // SDK device ticks are not Android's elapsed-realtime clock.
+    latest_time = now_ns();
+}
+
+void clear_pose(bool accept) {
+    std::lock_guard<std::mutex> lock(pose_mutex);
+    accepting_pose = accept;
+    latest_time = 0;
+}
+
+int64_t monotonic_ns() {
+    timespec ts{}; clock_gettime(CLOCK_MONOTONIC, &ts);
+    return int64_t(ts.tv_sec) * 1000000000LL + ts.tv_nsec;
+}
+struct CameraPose { double time; std::array<float, 7> pose; };
+std::mutex camera_mutex;
+std::deque<CameraPose> camera_poses;
+std::vector<uint8_t> camera_left, camera_right;
+bool camera_accepting = false, camera_wanted = false;
+int camera_width = 0, camera_height = 0;
+uint64_t camera_sequence = 0, camera_consumed = 0;
+StereoFrameGate camera_gate;
+uint64_t camera_input_sequence = 0;
+int64_t camera_receipt = 0;
+int64_t camera_pose_receipt = 0;
+double camera_source = 0;
+const CameraPose *matched_camera_pose(double source) {
+    const CameraPose *best = nullptr;
+    double distance = 0.005;
+    for (const auto &p : camera_poses) if (std::abs(p.time-source) < distance) {
+        best = &p; distance = std::abs(p.time-source);
+    }
+    return best;
+}
+void on_carina_pose(float *pose, double stamp) {
+    if (!pose || !std::isfinite(stamp)) return;
+    std::lock_guard<std::mutex> lock(camera_mutex);
+    if (!camera_accepting) return;
+    camera_pose_receipt = monotonic_ns();
+    CameraPose p{stamp, {}}; std::copy_n(pose, 7, p.pose.begin());
+    camera_poses.push_back(p);
+    while (camera_poses.size() > 64) camera_poses.pop_front();
+}
+void on_camera(char *left, char *right, char *, char *, double stamp, int width, int height) {
+    if (!left || !right || width <= 0 || height <= 0 || width > 2048 || height > 2048 || !std::isfinite(stamp)) return;
+    const auto received = monotonic_ns();
+    std::lock_guard<std::mutex> lock(camera_mutex);
+    if (!camera_accepting || !camera_wanted) return;
+    if (!camera_gate.Accept(stamp)) return;
+    const size_t size = size_t(width) * height;
+    camera_left.resize(size); camera_right.resize(size);
+    memcpy(camera_left.data(), left, size); memcpy(camera_right.data(), right, size);
+    camera_width = width; camera_height = height; camera_source = stamp; camera_receipt = received;
+    camera_input_sequence = camera_gate.received;
+    ++camera_sequence;
+}
+void clear_camera(bool enabled) {
+    std::lock_guard<std::mutex> lock(camera_mutex);
+    camera_accepting = enabled; camera_wanted = false;
+    camera_poses.clear(); camera_left.clear(); camera_right.clear();
+    camera_sequence = camera_consumed = 0;
+    camera_gate = {}; camera_input_sequence = 0;
+    camera_pose_receipt = 0;
+}
+
+struct Session {
+    XRDeviceProviderHandle device = nullptr;
+    int pid = 0;
+    int type = -1;
+    bool initialized = false;
+    bool started = false;
+    bool tracking = false;
+    bool native_dof = false;
+    bool switched_native = false;
+    int original_bypass_display = -1;
+    int saved_dof = -1;
+    int64_t consumed_time = 0;
+    jlong token = 0;
+    int spatial_status = 1;
+};
+std::unique_ptr<Session> session;
+jlong next_token = 0;
+
+void report(const char* step, int rc) {
+    if (rc < 0) __android_log_print(ANDROID_LOG_WARN, "VitureSdk", "%s: %d", step, rc);
+}
+
+int suspend_native_dof(Session& s) {
+    if (!s.native_dof) return 0;
+    int mode = xr_device_provider_native_get_mode(s.device);
+    if (mode < 0) return mode;
+    if (mode != 1) return 0;
+    if (s.saved_dof < 0) {
+        int dof = xr_device_provider_native_get_dof(s.device);
+        if (dof < 0) return dof;
+        s.saved_dof = dof;
+    }
+    return xr_device_provider_native_set_dof(s.device, VITURE_NATIVE_DOF_0);
+}
+
+void restore_native_dof(Session& s) {
+    if (s.saved_dof >= 0 && xr_device_provider_native_get_mode(s.device) == 1) {
+        report("restore native DOF", xr_device_provider_native_set_dof(s.device, s.saved_dof));
+    }
+    s.saved_dof = -1;
+}
+
+int tracking(Session& s, bool enabled) {
+    if (s.tracking == enabled) return 0;
+    if (!enabled) {
+        clear_pose(false);
+        int rc = s.type == XR_DEVICE_TYPE_VITURE_CARINA ? 0 :
+            xr_device_provider_close_imu(s.device, VITURE_IMU_MODE_POSE);
+        s.tracking = false;
+        restore_native_dof(s);
+        return rc;
+    }
+    int rc = suspend_native_dof(s);
+    if (rc < 0) return rc;
+    clear_pose(true);
+    s.consumed_time = 0;
+    if (s.type != XR_DEVICE_TYPE_VITURE_CARINA) {
+        int frequency = VITURE_IMU_FREQUENCY_MEDIUM_HIGH;
+        while (frequency >= VITURE_IMU_FREQUENCY_LOW &&
+               !xr_device_provider_is_product_support_imu_frequency(s.pid, VITURE_IMU_MODE_POSE, frequency)) --frequency;
+        rc = frequency < 0 ? VITURE_GLASSES_ERROR_NOT_SUPPORTED :
+            xr_device_provider_open_imu(s.device, VITURE_IMU_MODE_POSE, frequency);
+    }
+    if (rc == 0) s.tracking = true;
+    else { clear_pose(false); restore_native_dof(s); }
+    return rc;
+}
+
+void destroy(Session& s) {
+    clear_camera(false);
+    clear_pose(false);
+    clear_state(false);
+    if (s.device) {
+        if (s.tracking) report("close tracking", tracking(s, false));
+        if (s.switched_native && s.original_bypass_display >= 0) {
+            int rc = xr_device_provider_native_set_mode(s.device, 0);
+            if (rc == 0) rc = xr_device_provider_set_display_mode(s.device, s.original_bypass_display);
+            report("restore bypass mode", rc);
+        }
+        if (s.started) report("stop", xr_device_provider_stop(s.device));
+        if (s.initialized) report("shutdown", xr_device_provider_shutdown(s.device));
+        xr_device_provider_destroy(s.device);
+        s.device = nullptr;
+    }
+}
+
+int get_display(Session& s) {
+    if (s.native_dof) {
+        const int mode = xr_device_provider_native_get_mode(s.device);
+        if (mode < 0) return mode;
+        if (mode == 1) {
+            const int value = xr_device_provider_native_get_display_mode(s.device);
+            return value < 0 ? value : droiddeck::viture::from_native_mode(value);
+        }
+    }
+    return xr_device_provider_get_display_mode(s.device);
+}
+
+int set_display(Session& s, int standard) {
+    if (!s.native_dof) return xr_device_provider_set_display_mode(s.device, standard);
+    int mode = xr_device_provider_native_get_mode(s.device);
+    if (mode < 0) return mode;
+    if (mode == 0) {
+        int rc = xr_device_provider_set_display_mode(s.device, standard);
+        if (rc != VITURE_GLASSES_ERROR_NOT_SUPPORTED) return rc;
+        // Older Beast firmware exposes fewer bypass modes. Fall back to its
+        // separate native table only when the SDK explicitly rejects the mode.
+    }
+    const int native = droiddeck::viture::to_native_mode(standard);
+    if (native < 0) return native;
+    if (mode == 0) {
+        if (!s.switched_native) {
+            s.original_bypass_display = xr_device_provider_get_display_mode(s.device);
+            if (s.original_bypass_display < 0) return s.original_bypass_display;
+        }
+        int rc = xr_device_provider_native_set_mode(s.device, 1);
+        if (rc < 0) return rc;
+        s.switched_native = true;
+    }
+    int rc = xr_device_provider_native_set_display_mode(s.device, native);
+    if (rc == 0 && s.tracking) rc = suspend_native_dof(s);
+    if (rc < 0 && mode == 0) {
+        restore_native_dof(s);
+        int rollback = xr_device_provider_native_set_mode(s.device, 0);
+        if (rollback == 0) rollback = xr_device_provider_set_display_mode(s.device, s.original_bypass_display);
+        report("rollback display mode", rollback);
+        if (rollback == 0) s.switched_native = false;
+    }
+    return rc;
+}
+}
+
+#define JNI_METHOD(name) Java_com_droiddeck_launcher_glasses_VitureSdk_##name
+extern "C" JNIEXPORT jboolean JNICALL JNI_METHOD(nativeAvailable)(JNIEnv*, jobject) {
+    __android_log_print(ANDROID_LOG_INFO, "VitureSdk", "SDK %s", GetVersionString());
+    return JNI_TRUE;
+}
+
+extern "C" JNIEXPORT jstring JNICALL JNI_METHOD(nativeMarketName)(JNIEnv* env, jobject, jint pid) {
+    std::lock_guard<std::mutex> lock(api_mutex);
+    if (!xr_device_provider_is_product_id_valid(pid)) return nullptr;
+    char name[64]{};
+    int length = sizeof(name) - 1;
+    if (xr_device_provider_get_market_name(pid, name, &length) != 0) return nullptr;
+    name[sizeof(name) - 1] = 0;
+    return env->NewStringUTF(name);
+}
+
+extern "C" JNIEXPORT jlong JNICALL JNI_METHOD(nativeOpen)(JNIEnv* env, jobject, jint pid, jint fd, jstring cache, jboolean spatial) {
+    std::lock_guard<std::mutex> lock(api_mutex);
+    if (session || fd < 0 || !cache || !xr_device_provider_is_product_id_valid(pid)) return 0;
+    auto s = std::make_unique<Session>();
+    s->pid = pid;
+    s->device = xr_device_provider_create(pid, fd);
+    if (!s->device) return 0;
+    s->type = xr_device_provider_get_device_type(s->device);
+    s->native_dof = xr_device_provider_is_product_support_native_dof(pid) == 1;
+    int rc = s->type < 0 ? s->type : 0;
+    if (rc == 0) {
+        clear_state(true);
+        rc = xr_device_provider_register_state_callback(s->device, on_state);
+    }
+    if (rc == 0) {
+        rc = s->type == XR_DEVICE_TYPE_VITURE_CARINA ?
+            xr_device_provider_set_dof_type_carina(s->device, spatial ? 1 : 0) :
+            xr_device_provider_register_imu_pose_callback(s->device, on_pose);
+    }
+    if (rc == 0) {
+        const char* directory = env->GetStringUTFChars(cache, nullptr);
+        if (!directory) { destroy(*s); return 0; }
+        rc = xr_device_provider_initialize(s->device, nullptr, directory);
+        env->ReleaseStringUTFChars(cache, directory);
+        s->initialized = rc == 0;
+    }
+    if (rc == 0 && s->type == XR_DEVICE_TYPE_VITURE_CARINA && spatial) {
+        clear_camera(true);
+        rc = xr_device_provider_register_callbacks_carina(s->device, on_carina_pose, nullptr, nullptr, on_camera);
+    }
+    if (rc == 0) {
+        rc = xr_device_provider_start(s->device);
+        s->started = rc == 0;
+    }
+    if (rc != 0) { report("initialize/start", rc); destroy(*s); return 0; }
+    s->token = ++next_token;
+    session = std::move(s);
+    return session->token;
+}
+
+extern "C" JNIEXPORT jint JNICALL JNI_METHOD(nativeType)(JNIEnv*, jobject, jlong token) {
+    std::lock_guard<std::mutex> lock(api_mutex);
+    return session && session->token == token ? session->type : -1;
+}
+
+extern "C" JNIEXPORT jint JNICALL JNI_METHOD(nativeTracking)(JNIEnv*, jobject, jlong token, jboolean enabled) {
+    std::lock_guard<std::mutex> lock(api_mutex);
+    return session && session->token == token ? tracking(*session, enabled) : -1;
+}
+
+extern "C" JNIEXPORT jint JNICALL JNI_METHOD(nativeCommand)(JNIEnv*, jobject, jlong token, jint command, jint value) {
+    std::lock_guard<std::mutex> lock(api_mutex);
+    if (!session || session->token != token) return -1;
+    auto& s = *session;
+    switch (command) {
+        case 1: return get_display(s);
+        case 2: return set_display(s, value);
+        case 3: return xr_device_provider_get_brightness_level(s.device);
+        case 4: return xr_device_provider_set_brightness_level(s.device, value);
+        case 5: return xr_device_provider_get_volume_level(s.device);
+        case 6: return xr_device_provider_set_volume_level(s.device, value);
+        case 7: return xr_device_provider_set_film_mode(s.device, value ? 1.0f : 0.0f);
+        default: return VITURE_GLASSES_ERROR_NOT_SUPPORTED;
+    }
+}
+
+extern "C" JNIEXPORT jlong JNICALL JNI_METHOD(nativePose)(JNIEnv* env, jobject, jlong token, jfloatArray output) {
+    std::lock_guard<std::mutex> lock(api_mutex);
+    if (!session || session->token != token || !output || env->GetArrayLength(output) != 4) return -1;
+    auto& s = *session;
+    if (!s.tracking) return 0;
+    if (s.type == XR_DEVICE_TYPE_VITURE_CARINA) {
+        float pose[7]{};
+        int status = 1;
+        int rc = xr_device_provider_get_gl_pose_carina(s.device, pose, 0.0, &status);
+        if (rc < 0) return rc;
+        if (status != 0) return 0;
+        env->SetFloatArrayRegion(output, 0, 4, pose + 3);
+        return now_ns();
+    }
+    std::lock_guard<std::mutex> pose_lock(pose_mutex);
+    if (!latest_time || latest_time == s.consumed_time) return 0;
+    env->SetFloatArrayRegion(output, 0, 4, latest_pose.data());
+    s.consumed_time = latest_time;
+    return latest_time;
+}
+
+extern "C" JNIEXPORT jint JNICALL JNI_METHOD(nativeNextState)(JNIEnv* env, jobject, jlong token, jintArray output) {
+    std::lock_guard<std::mutex> lock(api_mutex);
+    if (!session || session->token != token || !output || env->GetArrayLength(output) != 2) return -1;
+    std::lock_guard<std::mutex> state_lock(pose_mutex);
+    for (int id = 0; id < int(state_values.size()); ++id) {
+        if (!(state_pending & (1u << id))) continue;
+        state_pending &= ~(1u << id);
+        const jint value[] = {id, state_values[id]};
+        env->SetIntArrayRegion(output, 0, 2, value);
+        return 1;
+    }
+    return 0;
+}
+
+extern "C" JNIEXPORT void JNICALL JNI_METHOD(nativeClose)(JNIEnv*, jobject, jlong token) {
+    std::lock_guard<std::mutex> lock(api_mutex);
+    if (session && session->token == token) { destroy(*session); session.reset(); }
+}
+
+extern "C" JNIEXPORT jlong JNICALL JNI_METHOD(nativeSpatialPose)(JNIEnv* env, jobject, jlong token,
+        jfloatArray output, jintArray state) {
+    std::lock_guard<std::mutex> lock(api_mutex);
+    if (!session || session->token != token || !session->tracking || session->type != XR_DEVICE_TYPE_VITURE_CARINA ||
+        !output || !state || env->GetArrayLength(output) != 7 || env->GetArrayLength(state) != 1) return 0;
+    float pose[7]{}; int status = 1;
+    int rc = xr_device_provider_get_gl_pose_carina(session->device, pose, 0.0, &status);
+    session->spatial_status = rc == 0 ? status : rc;
+    jint valid = rc == 0 ? status : rc;
+    if (valid == 0) {
+        std::lock_guard<std::mutex> lock(camera_mutex);
+        if (monotonic_ns()-camera_pose_receipt > 100000000LL) valid = 1;
+    }
+    env->SetIntArrayRegion(state, 0, 1, &valid);
+    env->SetFloatArrayRegion(output, 0, 7, pose);
+    return monotonic_ns();
+}
+extern "C" JNIEXPORT void JNICALL JNI_METHOD(nativeCapture)(JNIEnv*, jobject, jlong token, jboolean wanted, jint ratePermille) {
+    std::lock_guard<std::mutex> api(api_mutex);
+    if (!session || session->token != token) return;
+    std::lock_guard<std::mutex> lock(camera_mutex);
+    camera_wanted = wanted;
+    camera_gate.SetRatePermille(wanted ? ratePermille : 1000);
+    if (!wanted) camera_consumed = camera_sequence;
+}
+extern "C" JNIEXPORT jstring JNICALL JNI_METHOD(nativeFirmware)(JNIEnv* env, jobject, jlong token) {
+    std::lock_guard<std::mutex> api(api_mutex);
+    if (!session || session->token != token) return nullptr;
+    char value[256]{}; int length = 255;
+    if (xr_device_provider_get_glasses_version(session->device, value, &length) != 0) return nullptr;
+    value[255] = 0;
+    return env->NewStringUTF(value);
+}
+extern "C" JNIEXPORT jbyteArray JNICALL JNI_METHOD(nativeSerialHash)(JNIEnv* env, jobject, jlong token) {
+    std::lock_guard<std::mutex> api(api_mutex);
+    if (!session || session->token != token) return nullptr;
+    uint8_t hash[32]{};
+    const int rc = xr_device_provider_get_sn_hash(session->device, hash);
+    if (rc != 0) { report("read device identity", rc); return nullptr; }
+    auto result = env->NewByteArray(32);
+    if (result) env->SetByteArrayRegion(result, 0, 32, reinterpret_cast<const jbyte*>(hash));
+    return result;
+}
+extern "C" JNIEXPORT jdoubleArray JNICALL JNI_METHOD(nativeSpatialDiagnostics)(JNIEnv* env, jobject, jlong token) {
+    std::lock_guard<std::mutex> api(api_mutex);
+    if (!session || session->token != token) return nullptr;
+    std::lock_guard<std::mutex> lock(camera_mutex);
+    double values[3] = {double(session->spatial_status), camera_pose_receipt ? (monotonic_ns()-camera_pose_receipt)/1e6 : -1.0,
+        camera_poses.empty() ? -1.0 : (camera_poses.back().time-camera_source)*1000.0};
+    auto result=env->NewDoubleArray(3);
+    if(result)env->SetDoubleArrayRegion(result,0,3,values);
+    return result;
+}
+extern "C" JNIEXPORT jlong JNICALL JNI_METHOD(nativeStereo)(JNIEnv* env, jobject, jlong token,
+        jobject left, jobject right, jdoubleArray metadata, jfloatArray head, jboolean waitForPose) {
+    std::lock_guard<std::mutex> api(api_mutex);
+    if (!session || session->token != token || !left || !right || !metadata || !head ||
+        env->GetArrayLength(metadata) != 9 || env->GetArrayLength(head) != 7) return 0;
+    std::lock_guard<std::mutex> lock(camera_mutex);
+    if (!camera_wanted || camera_sequence == camera_consumed || camera_left.empty()) return 0;
+    const auto size = camera_left.size();
+    if (env->GetDirectBufferCapacity(left) < jlong(size) || env->GetDirectBufferCapacity(right) < jlong(size)) return -1;
+    auto l = env->GetDirectBufferAddress(left), r = env->GetDirectBufferAddress(right);
+    if (!l || !r) return -1;
+    const CameraPose *best = matched_camera_pose(camera_source);
+    if (waitForPose && !best && monotonic_ns()-camera_receipt < 35000000LL) return 0;
+    memcpy(l, camera_left.data(), size); memcpy(r, camera_right.data(), size);
+    double meta[9] = {double(camera_width), double(camera_height), camera_source, double(camera_receipt),
+                       double(token), double(camera_sequence), best ? 1.0 : 0.0,
+                       double(camera_input_sequence), double(camera_gate.skipped)};
+    env->SetDoubleArrayRegion(metadata, 0, 9, meta);
+    if (best) env->SetFloatArrayRegion(head, 0, 7, best->pose.data());
+    camera_consumed = camera_sequence;
+    return jlong(camera_sequence);
+}
+extern "C" JNIEXPORT jboolean JNICALL JNI_METHOD(nativeCameraSynchronized)(JNIEnv*, jobject, jlong token, jdouble source) {
+    std::lock_guard<std::mutex> api(api_mutex);
+    if (!session || session->token != token || !std::isfinite(source)) return JNI_FALSE;
+    std::lock_guard<std::mutex> lock(camera_mutex);
+    return camera_accepting && matched_camera_pose(source) != nullptr;
+}
+
+namespace {
+struct RgbUsbLog {
+    int savedStderr;
+    bool hadLevel;
+    std::string oldLevel;
+    explicit RgbUsbLog(int fd) : savedStderr(dup(STDERR_FILENO)),
+            hadLevel(getenv("LIBUSB_DEBUG") != nullptr), oldLevel(hadLevel ? getenv("LIBUSB_DEBUG") : "") {
+        fflush(stderr);
+        if (savedStderr >= 0) dup2(fd, STDERR_FILENO);
+        setenv("LIBUSB_DEBUG", "4", 1);
+    }
+    ~RgbUsbLog() {
+        fflush(stderr);
+        if (savedStderr >= 0) { dup2(savedStderr, STDERR_FILENO); close(savedStderr); }
+        if (hadLevel) setenv("LIBUSB_DEBUG", oldLevel.c_str(), 1); else unsetenv("LIBUSB_DEBUG");
+    }
+};
+
+void rgb_usb_state(int fd, const char* stage) {
+    uint8_t alternate = 0;
+    usbdevfs_ctrltransfer request{};
+    request.bRequestType=0x81; request.bRequest=0x0a; request.wIndex=1;
+    request.wLength=1; request.timeout=200; request.data=&alternate;
+    int result=ioctl(fd, USBDEVFS_CONTROL, &request);
+    fprintf(stderr,"RGB %s GET_INTERFACE result=%d errno=%d alternate=%u\n",stage,result,result<0 ? errno : 0,alternate);
+    for (int selector : {1, 2}) {
+        uint8_t size[2]{};
+        request.bRequestType=0xa1; request.bRequest=0x85; request.wValue=selector << 8;
+        request.wLength=2; request.data=size;
+        result=ioctl(fd,USBDEVFS_CONTROL,&request);
+        const unsigned length=result==2 ? unsigned(size[0]) | unsigned(size[1]) << 8 : 26;
+        uint8_t bytes[64]{};
+        request.bRequest=0x81; request.wLength=std::clamp(length,26u,64u); request.data=bytes;
+        result=ioctl(fd,USBDEVFS_CONTROL,&request);
+        fprintf(stderr,"RGB %s %s result=%d errno=%d bytes=",stage,selector==1 ? "PROBE" : "COMMIT",result,result<0 ? errno : 0);
+        for (int i=0;i<std::max(0,result);++i) fprintf(stderr,"%02x",bytes[i]);
+        fprintf(stderr,"\n");
+    }
+    fflush(stderr);
+}
+}
+
+extern "C" JNIEXPORT jbyteArray JNICALL JNI_METHOD(nativeRgbSnapshot)(JNIEnv* env, jobject,
+        jint vid, jint pid, jint fd, jlongArray metadata, jint logFd) {
+    if (fd < 0 || !metadata || env->GetArrayLength(metadata) != 7 ||
+        !xr_camera_provider_is_valid_camera(vid, pid)) return nullptr;
+    RgbUsbLog usbLog(logFd);
+    rgb_usb_state(fd,"before-create");
+    struct Capture {
+        std::mutex mutex;
+        std::condition_variable ready;
+        std::vector<uint8_t> jpeg;
+        unsigned frames = 0;
+        jlong values[7]{};
+    } capture;
+    auto camera = xr_camera_provider_create(vid, pid, fd);
+    if (!camera) { fprintf(stderr,"RGB provider create failed\n"); return nullptr; }
+    const int result = xr_camera_provider_start(camera, [](const XRCameraFrame* frame, void* data) {
+        auto& c = *static_cast<Capture*>(data);
+        std::lock_guard<std::mutex> lock(c.mutex);
+        ++c.frames;
+        if (!frame || !frame->data || frame->format != XR_CAMERA_FORMAT_MJPEG ||
+            frame->size < 4 || frame->size > 4 * 1024 * 1024) return;
+        c.jpeg.assign(frame->data, frame->data + frame->size);
+        c.values[0] = frame->width; c.values[1] = frame->height;
+        c.values[2] = frame->timestamp; c.values[3] = frame->sequence;
+        c.values[6] = monotonic_ns();
+        c.ready.notify_one();
+    }, &capture);
+    fprintf(stderr,"RGB start result=%d streaming=%d\n",result,xr_camera_provider_is_streaming(camera));
+    rgb_usb_state(fd,"after-start");
+    if (result == 0) {
+        {
+            std::unique_lock<std::mutex> lock(capture.mutex);
+            capture.ready.wait_for(lock, std::chrono::seconds(5), [&] { return capture.frames >= 10 && !capture.jpeg.empty(); });
+        }
+        fprintf(stderr,"RGB stop result=%d\n",xr_camera_provider_stop(camera));
+    }
+    xr_camera_provider_destroy(camera);
+    rgb_usb_state(fd,"after-destroy");
+    capture.values[4] = result;
+    capture.values[5] = capture.frames;
+    env->SetLongArrayRegion(metadata, 0, 7, capture.values);
+    if (capture.jpeg.empty()) return nullptr;
+    auto bytes = env->NewByteArray(static_cast<jsize>(capture.jpeg.size()));
+    if (bytes) env->SetByteArrayRegion(bytes, 0, static_cast<jsize>(capture.jpeg.size()),
+        reinterpret_cast<const jbyte*>(capture.jpeg.data()));
+    return bytes;
+}

app/src/main/cpp/viture/stereo_frame_gate.h

@@ -0,0 +1,29 @@
+#pragma once
+#include <cmath>
+#include <cstdint>
+
+struct StereoFrameGate {
+    uint64_t received = 0, skipped = 0;
+    void SetRatePermille(int rate) {
+        if (rate != 500 && rate != 600 && rate != 800 && rate != 1000) rate = 500;
+        if (ratePermille_ != rate) phase_ = 1000-rate;
+        ratePermille_ = rate;
+    }
+    void SetHalfRate(bool enabled) {
+        SetRatePermille(enabled ? 500 : 1000);
+    }
+    bool Accept(double source) {
+        if (!std::isfinite(source) || source <= 0) return false;
+        ++received;
+        if (source <= lastSource_) phase_ = 1000-ratePermille_;
+        lastSource_ = source;
+        phase_ += ratePermille_;
+        const bool copy = phase_ >= 1000;
+        if (copy) phase_ -= 1000;
+        if (!copy) ++skipped;
+        return copy;
+    }
+private:
+    int ratePermille_ = 1000, phase_ = 0;
+    double lastSource_ = 0;
+};

app/src/main/cpp/viture/uvc_bridge.cpp

@@ -0,0 +1,134 @@
+#include <jni.h>
+#include <libusb.h>
+#include <libuvc/libuvc.h>
+#include "mjpeg_payload.h"
+#include <algorithm>
+#include <chrono>
+#include <condition_variable>
+#include <cstdio>
+#include <cstdlib>
+#include <mutex>
+#include <string>
+#include <vector>
+#include <time.h>
+#include <unistd.h>
+
+namespace {
+struct UsbLog {
+    int saved;
+    bool hadLevel;
+    std::string level;
+    explicit UsbLog(int fd) : saved(dup(STDERR_FILENO)), hadLevel(getenv("LIBUSB_DEBUG") != nullptr),
+            level(hadLevel ? getenv("LIBUSB_DEBUG") : "") {
+        fflush(stderr);
+        if (saved >= 0) dup2(fd, STDERR_FILENO);
+        setenv("LIBUSB_DEBUG", "3", 1);
+        libusb_set_log_cb(nullptr, [](libusb_context*, libusb_log_level, const char* text) {
+            fputs(text, stderr);
+        }, LIBUSB_LOG_CB_GLOBAL);
+    }
+    ~UsbLog() {
+        libusb_set_log_cb(nullptr, nullptr, LIBUSB_LOG_CB_GLOBAL);
+        fflush(stderr);
+        if (saved >= 0) { dup2(saved, STDERR_FILENO); close(saved); }
+        if (hadLevel) setenv("LIBUSB_DEBUG", level.c_str(), 1); else unsetenv("LIBUSB_DEBUG");
+    }
+};
+
+struct Capture {
+    std::mutex mutex;
+    std::condition_variable ready;
+    std::vector<uint8_t> jpeg;
+    jlong values[14]{};
+    bool accepting = true;
+};
+
+jlong monotonic_ns() {
+    timespec now{};
+    clock_gettime(CLOCK_MONOTONIC, &now);
+    return now.tv_sec*1000000000LL+now.tv_nsec;
+}
+
+void finish_observation(Capture& capture) {
+    std::lock_guard<std::mutex> lock(capture.mutex);
+    if (!capture.accepting) return;
+    capture.accepting = false;
+    capture.values[12] = monotonic_ns();
+    if (capture.values[6]) capture.values[13] = capture.values[12]-capture.values[6];
+    capture.values[8] = std::max(capture.values[8],capture.values[13]);
+}
+
+void frame_received(uvc_frame_t* frame, void* user) {
+    auto& capture = *static_cast<Capture*>(user);
+    std::lock_guard<std::mutex> lock(capture.mutex);
+    if (!capture.accepting) return;
+    ++capture.values[5];
+    const auto* bytes = frame ? static_cast<const uint8_t*>(frame->data) : nullptr;
+    const size_t size = frame ? frame->data_bytes : 0;
+    const size_t jpegSize = frame && frame->frame_format == UVC_FRAME_FORMAT_MJPEG ? mjpeg_payload_size(bytes,size) : 0;
+    if (!jpegSize) {
+        ++capture.values[10];
+        return;
+    }
+    const jlong time = monotonic_ns();
+    capture.values[0]=frame->width; capture.values[1]=frame->height; capture.values[3]=frame->sequence;
+    if (!capture.values[7]) capture.values[7]=time;
+    if (capture.values[6]) capture.values[8]=std::max(capture.values[8],time-capture.values[6]);
+    capture.values[6]=time;
+    ++capture.values[9];
+    capture.values[11]+=jpegSize;
+    capture.jpeg.assign(bytes,bytes+jpegSize);
+    capture.ready.notify_one();
+}
+}
+
+extern "C" JNIEXPORT jbyteArray JNICALL
+Java_com_droiddeck_launcher_glasses_UvcRgbDiagnostic_nativeSnapshot(JNIEnv* env, jobject,
+        jint fd, jint width, jint height, jint fps, jint durationMs, jlongArray metadata, jint logFd) {
+    if (fd<0 || logFd<0 || !metadata || env->GetArrayLength(metadata)!=14 || width<160 || width>1920 ||
+            height<120 || height>1080 || fps<5 || fps>30 || durationMs<1000 || durationMs>30000) return nullptr;
+    UsbLog log(logFd);
+    Capture capture;
+    uvc_context_t* context=nullptr;
+    uvc_device_handle_t* camera=nullptr;
+    libusb_set_option(nullptr,LIBUSB_OPTION_NO_DEVICE_DISCOVERY);
+    int result=uvc_init(&context,nullptr);
+    fprintf(stderr,"UVC init=%d\n",result);
+    if (result==0) {
+        result=uvc_wrap(fd,context,&camera);
+        fprintf(stderr,"UVC wrap=%d\n",result);
+    }
+    if (result==0) {
+        uvc_print_diag(camera,stderr);
+        uvc_stream_ctrl_t control{};
+        result=uvc_get_stream_ctrl_format_size(camera,&control,UVC_FRAME_FORMAT_MJPEG,width,height,fps);
+        fprintf(stderr,"UVC negotiate=%d requested=%dx%d@%d\n",result,width,height,fps);
+        if (result==0) {
+            uvc_print_stream_ctrl(&control,stderr);
+            result=uvc_start_streaming(camera,&control,frame_received,&capture,0);
+            fprintf(stderr,"UVC start=%d\n",result);
+            if (result==0) {
+                {
+                    std::unique_lock<std::mutex> lock(capture.mutex);
+                    if (capture.ready.wait_for(lock,std::chrono::seconds(5),[&] { return !capture.jpeg.empty(); }))
+                        capture.ready.wait_for(lock,std::chrono::milliseconds(durationMs),[] { return false; });
+                }
+                finish_observation(capture);
+                uvc_stop_streaming(camera);
+            }
+        }
+    }
+    finish_observation(capture);
+    if (camera) uvc_close(camera);
+    if (context) uvc_exit(context);
+    capture.values[4]=result;
+    fprintf(stderr,"UVC result=%d callbacks=%lld complete=%lld invalid=%lld maxGapMs=%.3f tailMs=%.3f\n",result,
+        static_cast<long long>(capture.values[5]),static_cast<long long>(capture.values[9]),
+        static_cast<long long>(capture.values[10]),capture.values[8]/1e6,capture.values[13]/1e6);
+    env->SetLongArrayRegion(metadata,0,14,capture.values);
+    if (result!=0 || capture.jpeg.empty()) return nullptr;
+    auto bytes=env->NewByteArray(static_cast<jsize>(capture.jpeg.size()));
+    if (bytes) env->SetByteArrayRegion(bytes,0,static_cast<jsize>(capture.jpeg.size()),
+        reinterpret_cast<const jbyte*>(capture.jpeg.data()));
+    return bytes;
+}

app/src/main/cpp/waylandcomp/CMakeLists.txt

@@ -3,6 +3,7 @@ add_library(droiddeckwayland SHARED
         src/vk_present.c
         src/effects_chain.c
         src/cardboard.c
+        src/spatialpose.c
         src/vk_loader.c
         src/sc_layer.c
         src/ahb_swapchain.c

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

@@ -28,22 +28,25 @@ static float clampf(float v, float lo, float hi) { return v < lo ? lo : v > hi ?
 
 void cardboard_clamp(struct cardboard_params *p) {
     p->enabled = p->enabled ? 1 : 0;
-    p->source = p->source == CARDBOARD_SOURCE_SBS ? CARDBOARD_SOURCE_SBS : CARDBOARD_SOURCE_SCREEN;
+    if (p->source < CARDBOARD_SOURCE_SCREEN || p->source > CARDBOARD_SOURCE_FLAT) p->source = CARDBOARD_SOURCE_SCREEN;
     p->ipd_m = clampf(p->ipd_m, 0.0f, 0.1f);
     p->screen_dist_m = clampf(p->screen_dist_m, 0.5f, 50.0f);
     p->screen_width_m = clampf(p->screen_width_m, 0.2f, 60.0f);
     p->k1 = clampf(p->k1, -1.0f, 2.0f);
     p->k2 = clampf(p->k2, -1.0f, 2.0f);
-    p->fov_deg = clampf(p->fov_deg, 30.0f, 140.0f);
+    // Optical vertical FOV on supported glasses can be as low as ~22 degrees.
+    p->fov_deg = clampf(p->fov_deg, 20.0f, 140.0f);
     p->lens_inset = clampf(p->lens_inset, -0.25f, 0.25f);
     p->chroma = clampf(p->chroma, 0.0f, 0.05f);
+    p->mono = p->mono ? 1 : 0;
+    p->display_hz = clampf(p->display_hz, 0.0f, 240.0f);
 }
 
 void cardboard_push_constants(const struct cardboard_params *p, const float pose[9],
                               int src_w, int src_h, int out_w, int out_h, float out[24]) {
     for (int r = 0; r < 3; r++)
         for (int c = 0; c < 3; c++) out[r * 4 + c] = pose[r * 3 + c];
-    out[3] = p->ipd_m * 0.5f;
+    out[3] = p->mono ? 0.0f : p->ipd_m * 0.5f;
     out[7] = p->screen_dist_m;
     out[11] = p->screen_width_m * 0.5f;
     out[12] = p->k1;
@@ -54,13 +57,17 @@ void cardboard_push_constants(const struct cardboard_params *p, const float pose
     out[17] = (src_w > 0 && src_h > 0) ? (float)src_w / (float)src_h : 16.0f / 9.0f;
     if (p->source == CARDBOARD_SOURCE_SBS) out[17] *= 0.5f;
     out[18] = (float)p->source;
-    out[19] = (out_w > 0 && out_h > 0) ? ((float)out_w * 0.5f) / (float)out_h : 1.0f;
-    out[20] = out[21] = out[22] = out[23] = 0.0f;
+    out[19] = (out_w > 0 && out_h > 0) ? ((float)out_w * (p->mono ? 1.0f : 0.5f)) / (float)out_h : 1.0f;
+    out[20] = p->mono ? 1.0f : 0.0f;
+    out[21] = out[22] = out[23] = 0.0f;
+}
+
+void cardboard_push_translation(const struct cardboard_params *p, const float position[3], float out[24]) {
+    for (int i = 0; i < 3; ++i) out[21+i] = p->source == CARDBOARD_SOURCE_SCREEN && isfinite(position[i]) ? position[i] : 0.0f;
 }
 
 #ifndef CARDBOARD_HOST_TEST
 
-
 static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
 static struct cardboard_params g_set = {
     .enabled = 0, .source = CARDBOARD_SOURCE_SCREEN, .ipd_m = 0.064f, .screen_dist_m = 3.0f,
@@ -68,6 +75,7 @@ static struct cardboard_params g_set = {
 static float g_pose[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
 static volatile int g_changed = 1;
 
+static float g_position[3];
 static int g_live;
 static void shm_publish(int live);
 
@@ -81,13 +89,22 @@ void vkp_cardboard_set(const struct cardboard_params *p) {
     shm_publish(g_live);
     pthread_mutex_unlock(&g_lock);
     if (was != c.enabled || c.enabled)
-        droiddeck_log("cardboard", "%s: %s, ipd %.0f mm, screen %.1f m wide at %.1f m, lens k1 %.2f k2 %.2f, fov %.0f, inset %.3f, chroma %.3f",
-                      c.enabled ? "on" : "off", c.source == CARDBOARD_SOURCE_SBS ? "side-by-side source" : "virtual screen",
-                      c.ipd_m * 1000.0f, c.screen_width_m, c.screen_dist_m, c.k1, c.k2, c.fov_deg, c.lens_inset, c.chroma);
+        droiddeck_log("cardboard", "%s: %s%s, ipd %.0f mm, screen %.1f m wide at %.1f m, lens k1 %.2f k2 %.2f, fov %.0f, inset %.3f, chroma %.3f",
+                      c.enabled ? "on" : "off", c.source == CARDBOARD_SOURCE_SBS ? "side-by-side source" :
+                      c.source == CARDBOARD_SOURCE_FLAT ? "flat image in both eyes" : "virtual screen",
+                      c.mono ? " (one eye)" : "", c.ipd_m * 1000.0f, c.screen_width_m, c.screen_dist_m, c.k1, c.k2, c.fov_deg, c.lens_inset, c.chroma);
 }
 
 static struct droiddeck_headpose *g_shm;
 static int g_eye_w, g_eye_h;
+static int g_render_height;
+
+void vkp_cardboard_set_render_height(int height) {
+    pthread_mutex_lock(&g_lock);
+    g_render_height = height > 0 ? height : 0;
+    shm_publish(g_live);
+    pthread_mutex_unlock(&g_lock);
+}
 
 void vkp_cardboard_set_pose_file(const char *path) {
     pthread_mutex_lock(&g_lock);
@@ -101,6 +118,7 @@ void vkp_cardboard_set_pose_file(const char *path) {
                 g_shm->magic = DROIDDECK_HEADPOSE_MAGIC;
                 g_shm->version = DROIDDECK_HEADPOSE_VERSION;
                 memcpy(g_shm->rot, g_pose, sizeof(g_shm->rot));
+                shm_publish(g_live);
             }
         }
         if (fd >= 0) close(fd);
@@ -119,7 +137,10 @@ static void shm_publish(int live) {
     atomic_thread_fence(memory_order_release);
     memcpy(g_shm->rot, g_pose, sizeof(g_shm->rot));
     g_shm->ipd_m = g_set.ipd_m;
-    g_shm->flags = (live ? DROIDDECK_HEADPOSE_LIVE : 0u) | (g_set.enabled ? DROIDDECK_HEADPOSE_ENABLED : 0u);
+    g_shm->flags = (live ? DROIDDECK_HEADPOSE_LIVE : 0u) | (g_set.enabled ? DROIDDECK_HEADPOSE_ENABLED : 0u) |
+                   (g_set.mono ? DROIDDECK_HEADPOSE_MONO : 0u);
+    g_shm->display_hz = g_set.display_hz;
+    g_shm->render_height = (uint32_t)g_render_height;
     g_shm->time_ns = (int64_t)ts.tv_sec * 1000000000LL + ts.tv_nsec;
     g_shm->tan_half_fov = tanf(g_set.fov_deg * 0.5f * (float)M_PI / 180.0f);
     g_shm->eye_w = (uint32_t)(g_eye_w > 0 ? g_eye_w : 0);
@@ -130,22 +151,31 @@ static void shm_publish(int live) {
 }
 
 
-void vkp_cardboard_set_pose(const float m[9], int live) {
+void vkp_cardboard_set_spatial_pose(const float m[9], const float position[3], int live) {
     pthread_mutex_lock(&g_lock);
     memcpy(g_pose, m, sizeof(g_pose));
+    memcpy(g_position, position, sizeof(g_position));
     g_live = live;
     if (g_set.enabled && g_set.source == CARDBOARD_SOURCE_SCREEN) g_changed = 1;
     shm_publish(live);
     pthread_mutex_unlock(&g_lock);
 }
 
+void vkp_cardboard_set_pose(const float m[9], int live) {
+    const float zero[3] = {0};
+    vkp_cardboard_set_spatial_pose(m, zero, live);
+}
+
+
 static struct cardboard_params g_cur;
 static float g_cur_pose[9];
+static float g_cur_position[3];
 
 static void snapshot(void) {
     pthread_mutex_lock(&g_lock);
     g_cur = g_set;
     memcpy(g_cur_pose, g_pose, sizeof(g_cur_pose));
+    memcpy(g_cur_position, g_position, sizeof(g_cur_position));
     pthread_mutex_unlock(&g_lock);
 }
 
@@ -401,16 +431,18 @@ VkImage vkp_cardboard_run(VkCommandBuffer cmd, VkImage src, int src_w, int src_h
         if (!said) { said = 1; droiddeck_log("error", "cardboard: no descriptor for the frame; shown flat"); }
         return VK_NULL_HANDLE;
     }
-    if (g_eye_w != out_w / 2 || g_eye_h != out_h) {
+    snapshot();
+    int eye_w = g_cur.mono ? out_w : out_w / 2;
+    if (g_eye_w != eye_w || g_eye_h != out_h) {
         pthread_mutex_lock(&g_lock);
-        g_eye_w = out_w / 2;
+        g_eye_w = eye_w;
         g_eye_h = out_h;
         shm_publish(g_live);
         pthread_mutex_unlock(&g_lock);
     }
-    snapshot();
     struct { float ndc[4]; float rest[24]; } pc = {{-1.0f, -1.0f, 1.0f, 1.0f}, {0}};
     cardboard_push_constants(&g_cur, g_cur_pose, src_w, src_h, out_w, out_h, pc.rest);
+    cardboard_push_translation(&g_cur, g_cur_position, pc.rest);
 
     VkRenderPassBeginInfo rpi = {.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, .renderPass = g_rp,
                                  .framebuffer = g_t.fb, .renderArea = {{0, 0}, {(uint32_t)out_w, (uint32_t)out_h}}};

app/src/main/cpp/waylandcomp/src/cardboard.frag

@@ -10,7 +10,7 @@ layout(push_constant) uniform PC {
     vec4 rot2;
     vec4 lens;
     vec4 view;
-
+    vec4 extra;
 } pc;
 
 const vec3 BACKDROP = vec3(0.015, 0.015, 0.02);
@@ -24,14 +24,21 @@ vec3 eyeSample(vec2 tan, float eye) {
     if (pc.view.z > 0.5) {
         float tanH = pc.lens.z;
         vec2 s = vec2(tan.x / (tanH * pc.view.w), tan.y / tanH) * 0.5 + 0.5;
+        if (pc.view.z > 1.5) {
+            vec2 fit = max(vec2(pc.view.w / pc.view.y, pc.view.y / pc.view.w), vec2(1.0));
+            s = (s - 0.5) * fit + 0.5;
+            if (any(lessThan(s, vec2(0.0))) || any(greaterThan(s, vec2(1.0)))) return vec3(0.0);
+            return texture(Source, s).rgb;
+        }
         if (any(lessThan(s, vec2(0.0))) || any(greaterThan(s, vec2(1.0)))) return vec3(0.0);
         return texture(Source, vec2((s.x + eye) * 0.5, s.y)).rgb;
     }
     mat3 R = transpose(mat3(pc.rot0.xyz, pc.rot1.xyz, pc.rot2.xyz));
     vec3 d = R * normalize(vec3(tan.x, -tan.y, -1.0));
-    vec3 o = R * vec3((eye < 0.5 ? -1.0 : 1.0) * pc.rot0.w, 0.0, 0.0);
+    vec3 o = pc.extra.yzw + R * vec3((eye < 0.5 ? -1.0 : 1.0) * pc.rot0.w, 0.0, 0.0);
     if (d.z > -1e-4) return BACKDROP;
     float t = (-pc.rot1.w - o.z) / d.z;
+    if (t <= 0.0) return BACKDROP;
     vec3 hit = o + d * t;
     float halfW = pc.rot2.w, halfH = halfW / pc.view.y;
     vec2 s = vec2(hit.x / halfW, -hit.y / halfH) * 0.5 + 0.5;
@@ -40,9 +47,10 @@ vec3 eyeSample(vec2 tan, float eye) {
 }
 
 void main() {
-    float eye = uv.x < 0.5 ? 0.0 : 1.0;
-    vec2 local = vec2(uv.x * 2.0 - eye, uv.y);
-    float cx = 0.5 + (eye < 0.5 ? pc.view.x : -pc.view.x);
+    bool mono = pc.extra.x > 0.5;
+    float eye = mono || uv.x < 0.5 ? 0.0 : 1.0;
+    vec2 local = mono ? uv : vec2(uv.x * 2.0 - eye, uv.y);
+    float cx = mono ? 0.5 : 0.5 + (eye < 0.5 ? pc.view.x : -pc.view.x);
     vec2 p = local - vec2(cx, 0.5);
     float tanH = pc.lens.z;
     vec2 t = vec2(p.x * pc.view.w, p.y) * 2.0 * tanH;

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

@@ -3,7 +3,7 @@
 #define VK_USE_PLATFORM_ANDROID_KHR
 #include <vulkan/vulkan.h>
 
-enum { CARDBOARD_SOURCE_SCREEN = 0, CARDBOARD_SOURCE_SBS = 1 };
+enum { CARDBOARD_SOURCE_SCREEN = 0, CARDBOARD_SOURCE_SBS = 1, CARDBOARD_SOURCE_FLAT = 2 };
 
 struct cardboard_params {
     int enabled;
@@ -15,11 +15,15 @@ struct cardboard_params {
     float fov_deg;
     float lens_inset;
     float chroma;
+    int mono;
+    float display_hz;
 };
 
 void vkp_cardboard_set(const struct cardboard_params *p);
 void vkp_cardboard_set_pose(const float m[9], int live);
+void vkp_cardboard_set_spatial_pose(const float m[9], const float position[3], int live);
 void vkp_cardboard_set_pose_file(const char *path);
+void vkp_cardboard_set_render_height(int height);
 
 void vkp_cardboard_bind_device(VkDevice dev, const VkPhysicalDeviceMemoryProperties *memprops);
 int vkp_cardboard_active(void);
@@ -30,5 +34,6 @@ VkImage vkp_cardboard_run(VkCommandBuffer cmd, VkImage src, int src_w, int src_h
 void cardboard_clamp(struct cardboard_params *p);
 void cardboard_push_constants(const struct cardboard_params *p, const float pose[9],
                               int src_w, int src_h, int out_w, int out_h, float out[24]);
+void cardboard_push_translation(const struct cardboard_params *p, const float position[3], float out[24]);
 
 #endif

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

@@ -1,8 +1,9 @@
+	// 1115.1.0
 	 #pragma once
 const uint32_t cardboard_frag_code[] = {
-	0x07230203,0x00010000,0x0008000b,0x0000016d,0x00000000,0x00020011,0x00000001,0x0006000b,
+	0x07230203,0x00010000,0x0008000b,0x000001ba,0x00000000,0x00020011,0x00000001,0x0006000b,
 	0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001,
-	0x0007000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x000000ee,0x00000165,0x00030010,
+	0x0007000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x0000012d,0x000001b2,0x00030010,
 	0x00000004,0x00000007,0x00030003,0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d,
 	0x00000000,0x00070005,0x0000000d,0x69646e75,0x726f7473,0x66762874,0x31663b32,0x0000003b,
 	0x00030005,0x0000000b,0x00000074,0x00040005,0x0000000c,0x6c616373,0x00000065,0x00070005,
@@ -11,255 +12,306 @@ const uint32_t cardboard_frag_code[] = {
 	0x0000001e,0x00004350,0x00040006,0x0000001e,0x00000000,0x0063646e,0x00050006,0x0000001e,
 	0x00000001,0x30746f72,0x00000000,0x00050006,0x0000001e,0x00000002,0x31746f72,0x00000000,
 	0x00050006,0x0000001e,0x00000003,0x32746f72,0x00000000,0x00050006,0x0000001e,0x00000004,
-	0x736e656c,0x00000000,0x00050006,0x0000001e,0x00000005,0x77656976,0x00000000,0x00030005,
-	0x00000020,0x00006370,0x00040005,0x0000003f,0x486e6174,0x00000000,0x00030005,0x00000042,
-	0x00000073,0x00040005,0x00000068,0x72756f53,0x00006563,0x00030005,0x00000077,0x00000052,
-	0x00030005,0x00000094,0x00000064,0x00030005,0x0000009f,0x0000006f,0x00030005,0x000000b3,
-	0x00000074,0x00030005,0x000000bd,0x00746968,0x00040005,0x000000c3,0x666c6168,0x00000057,
-	0x00040005,0x000000c6,0x666c6168,0x00000048,0x00030005,0x000000cb,0x00000073,0x00030005,
-	0x000000ec,0x00657965,0x00030005,0x000000ee,0x00007675,0x00040005,0x000000f4,0x61636f6c,
-	0x0000006c,0x00030005,0x000000fe,0x00007863,0x00030005,0x0000010c,0x00000070,0x00040005,
-	0x00000111,0x486e6174,0x00000000,0x00030005,0x00000114,0x00000074,0x00030005,0x00000125,
-	0x00000063,0x00040005,0x00000129,0x61726170,0x0000006d,0x00040005,0x0000012b,0x61726170,
-	0x0000006d,0x00040005,0x0000012d,0x61726170,0x0000006d,0x00040005,0x0000012e,0x61726170,
-	0x0000006d,0x00040005,0x00000133,0x61726170,0x0000006d,0x00040005,0x00000135,0x61726170,
-	0x0000006d,0x00040005,0x00000137,0x61726170,0x0000006d,0x00040005,0x00000138,0x61726170,
-	0x0000006d,0x00040005,0x00000140,0x61726170,0x0000006d,0x00040005,0x00000142,0x61726170,
-	0x0000006d,0x00040005,0x00000144,0x61726170,0x0000006d,0x00040005,0x00000145,0x61726170,
-	0x0000006d,0x00040005,0x0000014b,0x61726170,0x0000006d,0x00040005,0x0000014d,0x61726170,
-	0x0000006d,0x00040005,0x0000014f,0x61726170,0x0000006d,0x00040005,0x00000150,0x61726170,
-	0x0000006d,0x00030005,0x00000153,0x00000065,0x00040005,0x00000159,0x65646166,0x00000000,
-	0x00050005,0x00000165,0x4374756f,0x726f6c6f,0x00000000,0x00030047,0x0000001e,0x00000002,
-	0x00050048,0x0000001e,0x00000000,0x00000023,0x00000000,0x00050048,0x0000001e,0x00000001,
-	0x00000023,0x00000010,0x00050048,0x0000001e,0x00000002,0x00000023,0x00000020,0x00050048,
-	0x0000001e,0x00000003,0x00000023,0x00000030,0x00050048,0x0000001e,0x00000004,0x00000023,
-	0x00000040,0x00050048,0x0000001e,0x00000005,0x00000023,0x00000050,0x00040047,0x00000068,
-	0x00000021,0x00000000,0x00040047,0x00000068,0x00000022,0x00000000,0x00040047,0x000000ee,
-	0x0000001e,0x00000000,0x00040047,0x00000165,0x0000001e,0x00000000,0x00020013,0x00000002,
-	0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x00000007,
-	0x00000006,0x00000002,0x00040020,0x00000008,0x00000007,0x00000007,0x00040020,0x00000009,
-	0x00000007,0x00000006,0x00050021,0x0000000a,0x00000007,0x00000008,0x00000009,0x00040017,
-	0x0000000f,0x00000006,0x00000003,0x00050021,0x00000010,0x0000000f,0x00000008,0x00000009,
-	0x0004002b,0x00000006,0x0000001c,0x3f800000,0x00040017,0x0000001d,0x00000006,0x00000004,
-	0x0008001e,0x0000001e,0x0000001d,0x0000001d,0x0000001d,0x0000001d,0x0000001d,0x0000001d,
-	0x00040020,0x0000001f,0x00000009,0x0000001e,0x0004003b,0x0000001f,0x00000020,0x00000009,
-	0x00040015,0x00000021,0x00000020,0x00000001,0x0004002b,0x00000021,0x00000022,0x00000004,
-	0x00040015,0x00000023,0x00000020,0x00000000,0x0004002b,0x00000023,0x00000024,0x00000000,
-	0x00040020,0x00000025,0x00000009,0x00000006,0x0004002b,0x00000023,0x0000002b,0x00000001,
-	0x0004002b,0x00000021,0x00000036,0x00000005,0x0004002b,0x00000023,0x00000037,0x00000002,
-	0x0004002b,0x00000006,0x0000003a,0x3f000000,0x00020014,0x0000003b,0x0004002b,0x00000023,
-	0x00000046,0x00000003,0x0004002b,0x00000006,0x00000054,0x00000000,0x0005002c,0x00000007,
-	0x00000055,0x00000054,0x00000054,0x00040017,0x00000056,0x0000003b,0x00000002,0x0005002c,
-	0x00000007,0x0000005d,0x0000001c,0x0000001c,0x0006002c,0x0000000f,0x00000063,0x00000054,
-	0x00000054,0x00000054,0x00090019,0x00000065,0x00000006,0x00000001,0x00000000,0x00000000,
-	0x00000000,0x00000001,0x00000000,0x0003001b,0x00000066,0x00000065,0x00040020,0x00000067,
-	0x00000000,0x00000066,0x0004003b,0x00000067,0x00000068,0x00000000,0x00040018,0x00000075,
-	0x0000000f,0x00000003,0x00040020,0x00000076,0x00000007,0x00000075,0x0004002b,0x00000021,
-	0x00000078,0x00000001,0x00040020,0x00000079,0x00000009,0x0000001d,0x0004002b,0x00000021,
-	0x0000007d,0x00000002,0x0004002b,0x00000021,0x00000081,0x00000003,0x00040020,0x00000093,
-	0x00000007,0x0000000f,0x0004002b,0x00000006,0x0000009b,0xbf800000,0x0004002b,0x00000006,
-	0x000000ab,0xb8d1b717,0x0004002b,0x00000006,0x000000af,0x3c75c28f,0x0004002b,0x00000006,
-	0x000000b0,0x3ca3d70a,0x0006002c,0x0000000f,0x000000b1,0x000000af,0x000000af,0x000000b0,
-	0x00040020,0x000000ed,0x00000001,0x00000007,0x0004003b,0x000000ed,0x000000ee,0x00000001,
-	0x00040020,0x000000ef,0x00000001,0x00000006,0x0004002b,0x00000006,0x000000f7,0x40000000,
-	0x0004002b,0x00000006,0x0000015a,0x3cf5c28f,0x00040020,0x00000164,0x00000003,0x0000001d,
-	0x0004003b,0x00000164,0x00000165,0x00000003,0x00050036,0x00000002,0x00000004,0x00000000,
-	0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000009,0x000000ec,0x00000007,0x0004003b,
-	0x00000008,0x000000f4,0x00000007,0x0004003b,0x00000009,0x000000fe,0x00000007,0x0004003b,
-	0x00000009,0x00000101,0x00000007,0x0004003b,0x00000008,0x0000010c,0x00000007,0x0004003b,
-	0x00000009,0x00000111,0x00000007,0x0004003b,0x00000008,0x00000114,0x00000007,0x0004003b,
-	0x00000093,0x00000125,0x00000007,0x0004003b,0x00000008,0x00000129,0x00000007,0x0004003b,
-	0x00000009,0x0000012b,0x00000007,0x0004003b,0x00000008,0x0000012d,0x00000007,0x0004003b,
-	0x00000009,0x0000012e,0x00000007,0x0004003b,0x00000008,0x00000133,0x00000007,0x0004003b,
-	0x00000009,0x00000135,0x00000007,0x0004003b,0x00000008,0x00000137,0x00000007,0x0004003b,
-	0x00000009,0x00000138,0x00000007,0x0004003b,0x00000008,0x00000140,0x00000007,0x0004003b,
-	0x00000009,0x00000142,0x00000007,0x0004003b,0x00000008,0x00000144,0x00000007,0x0004003b,
-	0x00000009,0x00000145,0x00000007,0x0004003b,0x00000008,0x0000014b,0x00000007,0x0004003b,
-	0x00000009,0x0000014d,0x00000007,0x0004003b,0x00000008,0x0000014f,0x00000007,0x0004003b,
-	0x00000009,0x00000150,0x00000007,0x0004003b,0x00000008,0x00000153,0x00000007,0x0004003b,
-	0x00000009,0x00000159,0x00000007,0x00050041,0x000000ef,0x000000f0,0x000000ee,0x00000024,
-	0x0004003d,0x00000006,0x000000f1,0x000000f0,0x000500b8,0x0000003b,0x000000f2,0x000000f1,
-	0x0000003a,0x000600a9,0x00000006,0x000000f3,0x000000f2,0x00000054,0x0000001c,0x0003003e,
-	0x000000ec,0x000000f3,0x00050041,0x000000ef,0x000000f5,0x000000ee,0x00000024,0x0004003d,
-	0x00000006,0x000000f6,0x000000f5,0x00050085,0x00000006,0x000000f8,0x000000f6,0x000000f7,
-	0x0004003d,0x00000006,0x000000f9,0x000000ec,0x00050083,0x00000006,0x000000fa,0x000000f8,
-	0x000000f9,0x00050041,0x000000ef,0x000000fb,0x000000ee,0x0000002b,0x0004003d,0x00000006,
-	0x000000fc,0x000000fb,0x00050050,0x00000007,0x000000fd,0x000000fa,0x000000fc,0x0003003e,
-	0x000000f4,0x000000fd,0x0004003d,0x00000006,0x000000ff,0x000000ec,0x000500b8,0x0000003b,
-	0x00000100,0x000000ff,0x0000003a,0x000300f7,0x00000103,0x00000000,0x000400fa,0x00000100,
-	0x00000102,0x00000106,0x000200f8,0x00000102,0x00060041,0x00000025,0x00000104,0x00000020,
-	0x00000036,0x00000024,0x0004003d,0x00000006,0x00000105,0x00000104,0x0003003e,0x00000101,
-	0x00000105,0x000200f9,0x00000103,0x000200f8,0x00000106,0x00060041,0x00000025,0x00000107,
-	0x00000020,0x00000036,0x00000024,0x0004003d,0x00000006,0x00000108,0x00000107,0x0004007f,
-	0x00000006,0x00000109,0x00000108,0x0003003e,0x00000101,0x00000109,0x000200f9,0x00000103,
-	0x000200f8,0x00000103,0x0004003d,0x00000006,0x0000010a,0x00000101,0x00050081,0x00000006,
-	0x0000010b,0x0000003a,0x0000010a,0x0003003e,0x000000fe,0x0000010b,0x0004003d,0x00000007,
-	0x0000010d,0x000000f4,0x0004003d,0x00000006,0x0000010e,0x000000fe,0x00050050,0x00000007,
-	0x0000010f,0x0000010e,0x0000003a,0x00050083,0x00000007,0x00000110,0x0000010d,0x0000010f,
-	0x0003003e,0x0000010c,0x00000110,0x00060041,0x00000025,0x00000112,0x00000020,0x00000022,
-	0x00000037,0x0004003d,0x00000006,0x00000113,0x00000112,0x0003003e,0x00000111,0x00000113,
-	0x00050041,0x00000009,0x00000115,0x0000010c,0x00000024,0x0004003d,0x00000006,0x00000116,
-	0x00000115,0x00060041,0x00000025,0x00000117,0x00000020,0x00000036,0x00000046,0x0004003d,
-	0x00000006,0x00000118,0x00000117,0x00050085,0x00000006,0x00000119,0x00000116,0x00000118,
-	0x00050041,0x00000009,0x0000011a,0x0000010c,0x0000002b,0x0004003d,0x00000006,0x0000011b,
-	0x0000011a,0x00050050,0x00000007,0x0000011c,0x00000119,0x0000011b,0x0005008e,0x00000007,
-	0x0000011d,0x0000011c,0x000000f7,0x0004003d,0x00000006,0x0000011e,0x00000111,0x0005008e,
-	0x00000007,0x0000011f,0x0000011d,0x0000011e,0x0003003e,0x00000114,0x0000011f,0x00060041,
-	0x00000025,0x00000120,0x00000020,0x00000022,0x00000046,0x0004003d,0x00000006,0x00000121,
-	0x00000120,0x000500ba,0x0000003b,0x00000122,0x00000121,0x00000054,0x000300f7,0x00000124,
-	0x00000000,0x000400fa,0x00000122,0x00000123,0x0000014a,0x000200f8,0x00000123,0x00060041,
-	0x00000025,0x00000126,0x00000020,0x00000022,0x00000046,0x0004003d,0x00000006,0x00000127,
-	0x00000126,0x00050083,0x00000006,0x00000128,0x0000001c,0x00000127,0x0004003d,0x00000007,
-	0x0000012a,0x00000114,0x0003003e,0x00000129,0x0000012a,0x0003003e,0x0000012b,0x00000128,
-	0x00060039,0x00000007,0x0000012c,0x0000000d,0x00000129,0x0000012b,0x0003003e,0x0000012d,
-	0x0000012c,0x0004003d,0x00000006,0x0000012f,0x000000ec,0x0003003e,0x0000012e,0x0000012f,
-	0x00060039,0x0000000f,0x00000130,0x00000013,0x0000012d,0x0000012e,0x00050051,0x00000006,
-	0x00000131,0x00000130,0x00000000,0x00050041,0x00000009,0x00000132,0x00000125,0x00000024,
-	0x0003003e,0x00000132,0x00000131,0x0004003d,0x00000007,0x00000134,0x00000114,0x0003003e,
-	0x00000133,0x00000134,0x0003003e,0x00000135,0x0000001c,0x00060039,0x00000007,0x00000136,
-	0x0000000d,0x00000133,0x00000135,0x0003003e,0x00000137,0x00000136,0x0004003d,0x00000006,
-	0x00000139,0x000000ec,0x0003003e,0x00000138,0x00000139,0x00060039,0x0000000f,0x0000013a,
-	0x00000013,0x00000137,0x00000138,0x00050051,0x00000006,0x0000013b,0x0000013a,0x00000001,
-	0x00050041,0x00000009,0x0000013c,0x00000125,0x0000002b,0x0003003e,0x0000013c,0x0000013b,
-	0x00060041,0x00000025,0x0000013d,0x00000020,0x00000022,0x00000046,0x0004003d,0x00000006,
-	0x0000013e,0x0000013d,0x00050081,0x00000006,0x0000013f,0x0000001c,0x0000013e,0x0004003d,
-	0x00000007,0x00000141,0x00000114,0x0003003e,0x00000140,0x00000141,0x0003003e,0x00000142,
-	0x0000013f,0x00060039,0x00000007,0x00000143,0x0000000d,0x00000140,0x00000142,0x0003003e,
-	0x00000144,0x00000143,0x0004003d,0x00000006,0x00000146,0x000000ec,0x0003003e,0x00000145,
-	0x00000146,0x00060039,0x0000000f,0x00000147,0x00000013,0x00000144,0x00000145,0x00050051,
-	0x00000006,0x00000148,0x00000147,0x00000002,0x00050041,0x00000009,0x00000149,0x00000125,
-	0x00000037,0x0003003e,0x00000149,0x00000148,0x000200f9,0x00000124,0x000200f8,0x0000014a,
-	0x0004003d,0x00000007,0x0000014c,0x00000114,0x0003003e,0x0000014b,0x0000014c,0x0003003e,
-	0x0000014d,0x0000001c,0x00060039,0x00000007,0x0000014e,0x0000000d,0x0000014b,0x0000014d,
-	0x0003003e,0x0000014f,0x0000014e,0x0004003d,0x00000006,0x00000151,0x000000ec,0x0003003e,
-	0x00000150,0x00000151,0x00060039,0x0000000f,0x00000152,0x00000013,0x0000014f,0x00000150,
-	0x0003003e,0x00000125,0x00000152,0x000200f9,0x00000124,0x000200f8,0x00000124,0x0004003d,
-	0x00000007,0x00000154,0x000000f4,0x0004003d,0x00000007,0x00000155,0x000000f4,0x00050050,
-	0x00000007,0x00000156,0x0000001c,0x0000001c,0x00050083,0x00000007,0x00000157,0x00000156,
-	0x00000155,0x0007000c,0x00000007,0x00000158,0x00000001,0x00000025,0x00000154,0x00000157,
-	0x0003003e,0x00000153,0x00000158,0x00050041,0x00000009,0x0000015b,0x00000153,0x00000024,
-	0x0004003d,0x00000006,0x0000015c,0x0000015b,0x00060041,0x00000025,0x0000015d,0x00000020,
-	0x00000036,0x00000046,0x0004003d,0x00000006,0x0000015e,0x0000015d,0x00050085,0x00000006,
-	0x0000015f,0x0000015c,0x0000015e,0x00050041,0x00000009,0x00000160,0x00000153,0x0000002b,
-	0x0004003d,0x00000006,0x00000161,0x00000160,0x0007000c,0x00000006,0x00000162,0x00000001,
-	0x00000025,0x0000015f,0x00000161,0x0008000c,0x00000006,0x00000163,0x00000001,0x00000031,
-	0x00000054,0x0000015a,0x00000162,0x0003003e,0x00000159,0x00000163,0x0004003d,0x0000000f,
-	0x00000166,0x00000125,0x0004003d,0x00000006,0x00000167,0x00000159,0x0005008e,0x0000000f,
-	0x00000168,0x00000166,0x00000167,0x00050051,0x00000006,0x00000169,0x00000168,0x00000000,
-	0x00050051,0x00000006,0x0000016a,0x00000168,0x00000001,0x00050051,0x00000006,0x0000016b,
-	0x00000168,0x00000002,0x00070050,0x0000001d,0x0000016c,0x00000169,0x0000016a,0x0000016b,
-	0x0000001c,0x0003003e,0x00000165,0x0000016c,0x000100fd,0x00010038,0x00050036,0x00000007,
-	0x0000000d,0x00000000,0x0000000a,0x00030037,0x00000008,0x0000000b,0x00030037,0x00000009,
-	0x0000000c,0x000200f8,0x0000000e,0x0004003b,0x00000009,0x00000015,0x00000007,0x0004003d,
-	0x00000007,0x00000016,0x0000000b,0x0004003d,0x00000007,0x00000017,0x0000000b,0x00050094,
-	0x00000006,0x00000018,0x00000016,0x00000017,0x0003003e,0x00000015,0x00000018,0x0004003d,
-	0x00000007,0x00000019,0x0000000b,0x0004003d,0x00000006,0x0000001a,0x0000000c,0x0005008e,
-	0x00000007,0x0000001b,0x00000019,0x0000001a,0x00060041,0x00000025,0x00000026,0x00000020,
-	0x00000022,0x00000024,0x0004003d,0x00000006,0x00000027,0x00000026,0x0004003d,0x00000006,
-	0x00000028,0x00000015,0x00050085,0x00000006,0x00000029,0x00000027,0x00000028,0x00050081,
-	0x00000006,0x0000002a,0x0000001c,0x00000029,0x00060041,0x00000025,0x0000002c,0x00000020,
-	0x00000022,0x0000002b,0x0004003d,0x00000006,0x0000002d,0x0000002c,0x0004003d,0x00000006,
-	0x0000002e,0x00000015,0x00050085,0x00000006,0x0000002f,0x0000002d,0x0000002e,0x0004003d,
-	0x00000006,0x00000030,0x00000015,0x00050085,0x00000006,0x00000031,0x0000002f,0x00000030,
-	0x00050081,0x00000006,0x00000032,0x0000002a,0x00000031,0x0005008e,0x00000007,0x00000033,
-	0x0000001b,0x00000032,0x000200fe,0x00000033,0x00010038,0x00050036,0x0000000f,0x00000013,
-	0x00000000,0x00000010,0x00030037,0x00000008,0x00000011,0x00030037,0x00000009,0x00000012,
-	0x000200f8,0x00000014,0x0004003b,0x00000009,0x0000003f,0x00000007,0x0004003b,0x00000008,
-	0x00000042,0x00000007,0x0004003b,0x00000076,0x00000077,0x00000007,0x0004003b,0x00000093,
-	0x00000094,0x00000007,0x0004003b,0x00000093,0x0000009f,0x00000007,0x0004003b,0x00000009,
-	0x000000b3,0x00000007,0x0004003b,0x00000093,0x000000bd,0x00000007,0x0004003b,0x00000009,
-	0x000000c3,0x00000007,0x0004003b,0x00000009,0x000000c6,0x00000007,0x0004003b,0x00000008,
-	0x000000cb,0x00000007,0x00060041,0x00000025,0x00000038,0x00000020,0x00000036,0x00000037,
-	0x0004003d,0x00000006,0x00000039,0x00000038,0x000500ba,0x0000003b,0x0000003c,0x00000039,
-	0x0000003a,0x000300f7,0x0000003e,0x00000000,0x000400fa,0x0000003c,0x0000003d,0x0000003e,
-	0x000200f8,0x0000003d,0x00060041,0x00000025,0x00000040,0x00000020,0x00000022,0x00000037,
-	0x0004003d,0x00000006,0x00000041,0x00000040,0x0003003e,0x0000003f,0x00000041,0x00050041,
-	0x00000009,0x00000043,0x00000011,0x00000024,0x0004003d,0x00000006,0x00000044,0x00000043,
-	0x0004003d,0x00000006,0x00000045,0x0000003f,0x00060041,0x00000025,0x00000047,0x00000020,
-	0x00000036,0x00000046,0x0004003d,0x00000006,0x00000048,0x00000047,0x00050085,0x00000006,
-	0x00000049,0x00000045,0x00000048,0x00050088,0x00000006,0x0000004a,0x00000044,0x00000049,
-	0x00050041,0x00000009,0x0000004b,0x00000011,0x0000002b,0x0004003d,0x00000006,0x0000004c,
-	0x0000004b,0x0004003d,0x00000006,0x0000004d,0x0000003f,0x00050088,0x00000006,0x0000004e,
-	0x0000004c,0x0000004d,0x00050050,0x00000007,0x0000004f,0x0000004a,0x0000004e,0x0005008e,
-	0x00000007,0x00000050,0x0000004f,0x0000003a,0x00050050,0x00000007,0x00000051,0x0000003a,
-	0x0000003a,0x00050081,0x00000007,0x00000052,0x00000050,0x00000051,0x0003003e,0x00000042,
-	0x00000052,0x0004003d,0x00000007,0x00000053,0x00000042,0x000500b8,0x00000056,0x00000057,
-	0x00000053,0x00000055,0x0004009a,0x0000003b,0x00000058,0x00000057,0x000400a8,0x0000003b,
-	0x00000059,0x00000058,0x000300f7,0x0000005b,0x00000000,0x000400fa,0x00000059,0x0000005a,
-	0x0000005b,0x000200f8,0x0000005a,0x0004003d,0x00000007,0x0000005c,0x00000042,0x000500ba,
-	0x00000056,0x0000005e,0x0000005c,0x0000005d,0x0004009a,0x0000003b,0x0000005f,0x0000005e,
-	0x000200f9,0x0000005b,0x000200f8,0x0000005b,0x000700f5,0x0000003b,0x00000060,0x00000058,
-	0x0000003d,0x0000005f,0x0000005a,0x000300f7,0x00000062,0x00000000,0x000400fa,0x00000060,
-	0x00000061,0x00000062,0x000200f8,0x00000061,0x000200fe,0x00000063,0x000200f8,0x00000062,
-	0x0004003d,0x00000066,0x00000069,0x00000068,0x00050041,0x00000009,0x0000006a,0x00000042,
-	0x00000024,0x0004003d,0x00000006,0x0000006b,0x0000006a,0x0004003d,0x00000006,0x0000006c,
-	0x00000012,0x00050081,0x00000006,0x0000006d,0x0000006b,0x0000006c,0x00050085,0x00000006,
-	0x0000006e,0x0000006d,0x0000003a,0x00050041,0x00000009,0x0000006f,0x00000042,0x0000002b,
-	0x0004003d,0x00000006,0x00000070,0x0000006f,0x00050050,0x00000007,0x00000071,0x0000006e,
-	0x00000070,0x00050057,0x0000001d,0x00000072,0x00000069,0x00000071,0x0008004f,0x0000000f,
-	0x00000073,0x00000072,0x00000072,0x00000000,0x00000001,0x00000002,0x000200fe,0x00000073,
-	0x000200f8,0x0000003e,0x00050041,0x00000079,0x0000007a,0x00000020,0x00000078,0x0004003d,
-	0x0000001d,0x0000007b,0x0000007a,0x0008004f,0x0000000f,0x0000007c,0x0000007b,0x0000007b,
-	0x00000000,0x00000001,0x00000002,0x00050041,0x00000079,0x0000007e,0x00000020,0x0000007d,
-	0x0004003d,0x0000001d,0x0000007f,0x0000007e,0x0008004f,0x0000000f,0x00000080,0x0000007f,
-	0x0000007f,0x00000000,0x00000001,0x00000002,0x00050041,0x00000079,0x00000082,0x00000020,
-	0x00000081,0x0004003d,0x0000001d,0x00000083,0x00000082,0x0008004f,0x0000000f,0x00000084,
-	0x00000083,0x00000083,0x00000000,0x00000001,0x00000002,0x00050051,0x00000006,0x00000085,
-	0x0000007c,0x00000000,0x00050051,0x00000006,0x00000086,0x0000007c,0x00000001,0x00050051,
-	0x00000006,0x00000087,0x0000007c,0x00000002,0x00050051,0x00000006,0x00000088,0x00000080,
-	0x00000000,0x00050051,0x00000006,0x00000089,0x00000080,0x00000001,0x00050051,0x00000006,
-	0x0000008a,0x00000080,0x00000002,0x00050051,0x00000006,0x0000008b,0x00000084,0x00000000,
-	0x00050051,0x00000006,0x0000008c,0x00000084,0x00000001,0x00050051,0x00000006,0x0000008d,
-	0x00000084,0x00000002,0x00060050,0x0000000f,0x0000008e,0x00000085,0x00000086,0x00000087,
-	0x00060050,0x0000000f,0x0000008f,0x00000088,0x00000089,0x0000008a,0x00060050,0x0000000f,
-	0x00000090,0x0000008b,0x0000008c,0x0000008d,0x00060050,0x00000075,0x00000091,0x0000008e,
-	0x0000008f,0x00000090,0x00040054,0x00000075,0x00000092,0x00000091,0x0003003e,0x00000077,
-	0x00000092,0x0004003d,0x00000075,0x00000095,0x00000077,0x00050041,0x00000009,0x00000096,
-	0x00000011,0x00000024,0x0004003d,0x00000006,0x00000097,0x00000096,0x00050041,0x00000009,
-	0x00000098,0x00000011,0x0000002b,0x0004003d,0x00000006,0x00000099,0x00000098,0x0004007f,
-	0x00000006,0x0000009a,0x00000099,0x00060050,0x0000000f,0x0000009c,0x00000097,0x0000009a,
-	0x0000009b,0x0006000c,0x0000000f,0x0000009d,0x00000001,0x00000045,0x0000009c,0x00050091,
-	0x0000000f,0x0000009e,0x00000095,0x0000009d,0x0003003e,0x00000094,0x0000009e,0x0004003d,
-	0x00000075,0x000000a0,0x00000077,0x0004003d,0x00000006,0x000000a1,0x00000012,0x000500b8,
-	0x0000003b,0x000000a2,0x000000a1,0x0000003a,0x000600a9,0x00000006,0x000000a3,0x000000a2,
-	0x0000009b,0x0000001c,0x00060041,0x00000025,0x000000a4,0x00000020,0x00000078,0x00000046,
-	0x0004003d,0x00000006,0x000000a5,0x000000a4,0x00050085,0x00000006,0x000000a6,0x000000a3,
-	0x000000a5,0x00060050,0x0000000f,0x000000a7,0x000000a6,0x00000054,0x00000054,0x00050091,
-	0x0000000f,0x000000a8,0x000000a0,0x000000a7,0x0003003e,0x0000009f,0x000000a8,0x00050041,
-	0x00000009,0x000000a9,0x00000094,0x00000037,0x0004003d,0x00000006,0x000000aa,0x000000a9,
-	0x000500ba,0x0000003b,0x000000ac,0x000000aa,0x000000ab,0x000300f7,0x000000ae,0x00000000,
-	0x000400fa,0x000000ac,0x000000ad,0x000000ae,0x000200f8,0x000000ad,0x000200fe,0x000000b1,
-	0x000200f8,0x000000ae,0x00060041,0x00000025,0x000000b4,0x00000020,0x0000007d,0x00000046,
-	0x0004003d,0x00000006,0x000000b5,0x000000b4,0x0004007f,0x00000006,0x000000b6,0x000000b5,
-	0x00050041,0x00000009,0x000000b7,0x0000009f,0x00000037,0x0004003d,0x00000006,0x000000b8,
-	0x000000b7,0x00050083,0x00000006,0x000000b9,0x000000b6,0x000000b8,0x00050041,0x00000009,
-	0x000000ba,0x00000094,0x00000037,0x0004003d,0x00000006,0x000000bb,0x000000ba,0x00050088,
-	0x00000006,0x000000bc,0x000000b9,0x000000bb,0x0003003e,0x000000b3,0x000000bc,0x0004003d,
-	0x0000000f,0x000000be,0x0000009f,0x0004003d,0x0000000f,0x000000bf,0x00000094,0x0004003d,
-	0x00000006,0x000000c0,0x000000b3,0x0005008e,0x0000000f,0x000000c1,0x000000bf,0x000000c0,
-	0x00050081,0x0000000f,0x000000c2,0x000000be,0x000000c1,0x0003003e,0x000000bd,0x000000c2,
-	0x00060041,0x00000025,0x000000c4,0x00000020,0x00000081,0x00000046,0x0004003d,0x00000006,
-	0x000000c5,0x000000c4,0x0003003e,0x000000c3,0x000000c5,0x0004003d,0x00000006,0x000000c7,
-	0x000000c3,0x00060041,0x00000025,0x000000c8,0x00000020,0x00000036,0x0000002b,0x0004003d,
-	0x00000006,0x000000c9,0x000000c8,0x00050088,0x00000006,0x000000ca,0x000000c7,0x000000c9,
-	0x0003003e,0x000000c6,0x000000ca,0x00050041,0x00000009,0x000000cc,0x000000bd,0x00000024,
-	0x0004003d,0x00000006,0x000000cd,0x000000cc,0x0004003d,0x00000006,0x000000ce,0x000000c3,
-	0x00050088,0x00000006,0x000000cf,0x000000cd,0x000000ce,0x00050041,0x00000009,0x000000d0,
-	0x000000bd,0x0000002b,0x0004003d,0x00000006,0x000000d1,0x000000d0,0x0004007f,0x00000006,
-	0x000000d2,0x000000d1,0x0004003d,0x00000006,0x000000d3,0x000000c6,0x00050088,0x00000006,
-	0x000000d4,0x000000d2,0x000000d3,0x00050050,0x00000007,0x000000d5,0x000000cf,0x000000d4,
-	0x0005008e,0x00000007,0x000000d6,0x000000d5,0x0000003a,0x00050050,0x00000007,0x000000d7,
-	0x0000003a,0x0000003a,0x00050081,0x00000007,0x000000d8,0x000000d6,0x000000d7,0x0003003e,
-	0x000000cb,0x000000d8,0x0004003d,0x00000007,0x000000d9,0x000000cb,0x000500b8,0x00000056,
-	0x000000da,0x000000d9,0x00000055,0x0004009a,0x0000003b,0x000000db,0x000000da,0x000400a8,
-	0x0000003b,0x000000dc,0x000000db,0x000300f7,0x000000de,0x00000000,0x000400fa,0x000000dc,
-	0x000000dd,0x000000de,0x000200f8,0x000000dd,0x0004003d,0x00000007,0x000000df,0x000000cb,
-	0x000500ba,0x00000056,0x000000e0,0x000000df,0x0000005d,0x0004009a,0x0000003b,0x000000e1,
-	0x000000e0,0x000200f9,0x000000de,0x000200f8,0x000000de,0x000700f5,0x0000003b,0x000000e2,
-	0x000000db,0x000000ae,0x000000e1,0x000000dd,0x000300f7,0x000000e4,0x00000000,0x000400fa,
-	0x000000e2,0x000000e3,0x000000e4,0x000200f8,0x000000e3,0x000200fe,0x000000b1,0x000200f8,
-	0x000000e4,0x0004003d,0x00000066,0x000000e6,0x00000068,0x0004003d,0x00000007,0x000000e7,
-	0x000000cb,0x00050057,0x0000001d,0x000000e8,0x000000e6,0x000000e7,0x0008004f,0x0000000f,
-	0x000000e9,0x000000e8,0x000000e8,0x00000000,0x00000001,0x00000002,0x000200fe,0x000000e9,
-	0x00010038
+	0x736e656c,0x00000000,0x00050006,0x0000001e,0x00000005,0x77656976,0x00000000,0x00050006,
+	0x0000001e,0x00000006,0x72747865,0x00000061,0x00030005,0x00000020,0x00006370,0x00040005,
+	0x0000003f,0x486e6174,0x00000000,0x00030005,0x00000042,0x00000073,0x00030005,0x00000059,
+	0x00746966,0x00040005,0x00000082,0x72756f53,0x00006563,0x00030005,0x000000a3,0x00000052,
+	0x00030005,0x000000c0,0x00000064,0x00030005,0x000000cb,0x0000006f,0x00030005,0x000000e4,
+	0x00000074,0x00030005,0x000000f3,0x00746968,0x00040005,0x000000f9,0x666c6168,0x00000057,
+	0x00040005,0x000000fc,0x666c6168,0x00000048,0x00030005,0x00000101,0x00000073,0x00040005,
+	0x00000123,0x6f6e6f6d,0x00000000,0x00030005,0x00000127,0x00657965,0x00030005,0x0000012d,
+	0x00007675,0x00040005,0x00000134,0x61636f6c,0x0000006c,0x00030005,0x00000145,0x00007863,
+	0x00030005,0x00000159,0x00000070,0x00040005,0x0000015e,0x486e6174,0x00000000,0x00030005,
+	0x00000161,0x00000074,0x00030005,0x00000172,0x00000063,0x00040005,0x00000176,0x61726170,
+	0x0000006d,0x00040005,0x00000178,0x61726170,0x0000006d,0x00040005,0x0000017a,0x61726170,
+	0x0000006d,0x00040005,0x0000017b,0x61726170,0x0000006d,0x00040005,0x00000180,0x61726170,
+	0x0000006d,0x00040005,0x00000182,0x61726170,0x0000006d,0x00040005,0x00000184,0x61726170,
+	0x0000006d,0x00040005,0x00000185,0x61726170,0x0000006d,0x00040005,0x0000018d,0x61726170,
+	0x0000006d,0x00040005,0x0000018f,0x61726170,0x0000006d,0x00040005,0x00000191,0x61726170,
+	0x0000006d,0x00040005,0x00000192,0x61726170,0x0000006d,0x00040005,0x00000198,0x61726170,
+	0x0000006d,0x00040005,0x0000019a,0x61726170,0x0000006d,0x00040005,0x0000019c,0x61726170,
+	0x0000006d,0x00040005,0x0000019d,0x61726170,0x0000006d,0x00030005,0x000001a0,0x00000065,
+	0x00040005,0x000001a6,0x65646166,0x00000000,0x00050005,0x000001b2,0x4374756f,0x726f6c6f,
+	0x00000000,0x00030047,0x0000001e,0x00000002,0x00050048,0x0000001e,0x00000000,0x00000023,
+	0x00000000,0x00050048,0x0000001e,0x00000001,0x00000023,0x00000010,0x00050048,0x0000001e,
+	0x00000002,0x00000023,0x00000020,0x00050048,0x0000001e,0x00000003,0x00000023,0x00000030,
+	0x00050048,0x0000001e,0x00000004,0x00000023,0x00000040,0x00050048,0x0000001e,0x00000005,
+	0x00000023,0x00000050,0x00050048,0x0000001e,0x00000006,0x00000023,0x00000060,0x00040047,
+	0x00000082,0x00000021,0x00000000,0x00040047,0x00000082,0x00000022,0x00000000,0x00040047,
+	0x0000012d,0x0000001e,0x00000000,0x00040047,0x000001b2,0x0000001e,0x00000000,0x00020013,
+	0x00000002,0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,
+	0x00000007,0x00000006,0x00000002,0x00040020,0x00000008,0x00000007,0x00000007,0x00040020,
+	0x00000009,0x00000007,0x00000006,0x00050021,0x0000000a,0x00000007,0x00000008,0x00000009,
+	0x00040017,0x0000000f,0x00000006,0x00000003,0x00050021,0x00000010,0x0000000f,0x00000008,
+	0x00000009,0x0004002b,0x00000006,0x0000001c,0x3f800000,0x00040017,0x0000001d,0x00000006,
+	0x00000004,0x0009001e,0x0000001e,0x0000001d,0x0000001d,0x0000001d,0x0000001d,0x0000001d,
+	0x0000001d,0x0000001d,0x00040020,0x0000001f,0x00000009,0x0000001e,0x0004003b,0x0000001f,
+	0x00000020,0x00000009,0x00040015,0x00000021,0x00000020,0x00000001,0x0004002b,0x00000021,
+	0x00000022,0x00000004,0x00040015,0x00000023,0x00000020,0x00000000,0x0004002b,0x00000023,
+	0x00000024,0x00000000,0x00040020,0x00000025,0x00000009,0x00000006,0x0004002b,0x00000023,
+	0x0000002b,0x00000001,0x0004002b,0x00000021,0x00000036,0x00000005,0x0004002b,0x00000023,
+	0x00000037,0x00000002,0x0004002b,0x00000006,0x0000003a,0x3f000000,0x00020014,0x0000003b,
+	0x0004002b,0x00000023,0x00000046,0x00000003,0x0004002b,0x00000006,0x00000055,0x3fc00000,
+	0x0005002c,0x00000007,0x00000065,0x0000001c,0x0000001c,0x0004002b,0x00000006,0x0000006f,
+	0x00000000,0x0005002c,0x00000007,0x00000070,0x0000006f,0x0000006f,0x00040017,0x00000071,
+	0x0000003b,0x00000002,0x0006002c,0x0000000f,0x0000007d,0x0000006f,0x0000006f,0x0000006f,
+	0x00090019,0x0000007f,0x00000006,0x00000001,0x00000000,0x00000000,0x00000000,0x00000001,
+	0x00000000,0x0003001b,0x00000080,0x0000007f,0x00040020,0x00000081,0x00000000,0x00000080,
+	0x0004003b,0x00000081,0x00000082,0x00000000,0x00040018,0x000000a1,0x0000000f,0x00000003,
+	0x00040020,0x000000a2,0x00000007,0x000000a1,0x0004002b,0x00000021,0x000000a4,0x00000001,
+	0x00040020,0x000000a5,0x00000009,0x0000001d,0x0004002b,0x00000021,0x000000a9,0x00000002,
+	0x0004002b,0x00000021,0x000000ad,0x00000003,0x00040020,0x000000bf,0x00000007,0x0000000f,
+	0x0004002b,0x00000006,0x000000c7,0xbf800000,0x0004002b,0x00000021,0x000000cc,0x00000006,
+	0x0004002b,0x00000006,0x000000dc,0xb8d1b717,0x0004002b,0x00000006,0x000000e0,0x3c75c28f,
+	0x0004002b,0x00000006,0x000000e1,0x3ca3d70a,0x0006002c,0x0000000f,0x000000e2,0x000000e0,
+	0x000000e0,0x000000e1,0x00040020,0x00000122,0x00000007,0x0000003b,0x00040020,0x0000012c,
+	0x00000001,0x00000007,0x0004003b,0x0000012c,0x0000012d,0x00000001,0x00040020,0x0000012e,
+	0x00000001,0x00000006,0x0004002b,0x00000006,0x0000013d,0x40000000,0x0004002b,0x00000006,
+	0x000001a7,0x3cf5c28f,0x00040020,0x000001b1,0x00000003,0x0000001d,0x0004003b,0x000001b1,
+	0x000001b2,0x00000003,0x00050036,0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8,
+	0x00000005,0x0004003b,0x00000122,0x00000123,0x00000007,0x0004003b,0x00000009,0x00000127,
+	0x00000007,0x0004003b,0x00000008,0x00000134,0x00000007,0x0004003b,0x00000008,0x00000136,
+	0x00000007,0x0004003b,0x00000009,0x00000145,0x00000007,0x0004003b,0x00000009,0x00000147,
+	0x00000007,0x0004003b,0x00000009,0x0000014d,0x00000007,0x0004003b,0x00000008,0x00000159,
+	0x00000007,0x0004003b,0x00000009,0x0000015e,0x00000007,0x0004003b,0x00000008,0x00000161,
+	0x00000007,0x0004003b,0x000000bf,0x00000172,0x00000007,0x0004003b,0x00000008,0x00000176,
+	0x00000007,0x0004003b,0x00000009,0x00000178,0x00000007,0x0004003b,0x00000008,0x0000017a,
+	0x00000007,0x0004003b,0x00000009,0x0000017b,0x00000007,0x0004003b,0x00000008,0x00000180,
+	0x00000007,0x0004003b,0x00000009,0x00000182,0x00000007,0x0004003b,0x00000008,0x00000184,
+	0x00000007,0x0004003b,0x00000009,0x00000185,0x00000007,0x0004003b,0x00000008,0x0000018d,
+	0x00000007,0x0004003b,0x00000009,0x0000018f,0x00000007,0x0004003b,0x00000008,0x00000191,
+	0x00000007,0x0004003b,0x00000009,0x00000192,0x00000007,0x0004003b,0x00000008,0x00000198,
+	0x00000007,0x0004003b,0x00000009,0x0000019a,0x00000007,0x0004003b,0x00000008,0x0000019c,
+	0x00000007,0x0004003b,0x00000009,0x0000019d,0x00000007,0x0004003b,0x00000008,0x000001a0,
+	0x00000007,0x0004003b,0x00000009,0x000001a6,0x00000007,0x00060041,0x00000025,0x00000124,
+	0x00000020,0x000000cc,0x00000024,0x0004003d,0x00000006,0x00000125,0x00000124,0x000500ba,
+	0x0000003b,0x00000126,0x00000125,0x0000003a,0x0003003e,0x00000123,0x00000126,0x0004003d,
+	0x0000003b,0x00000128,0x00000123,0x000400a8,0x0000003b,0x00000129,0x00000128,0x000300f7,
+	0x0000012b,0x00000000,0x000400fa,0x00000129,0x0000012a,0x0000012b,0x000200f8,0x0000012a,
+	0x00050041,0x0000012e,0x0000012f,0x0000012d,0x00000024,0x0004003d,0x00000006,0x00000130,
+	0x0000012f,0x000500b8,0x0000003b,0x00000131,0x00000130,0x0000003a,0x000200f9,0x0000012b,
+	0x000200f8,0x0000012b,0x000700f5,0x0000003b,0x00000132,0x00000128,0x00000005,0x00000131,
+	0x0000012a,0x000600a9,0x00000006,0x00000133,0x00000132,0x0000006f,0x0000001c,0x0003003e,
+	0x00000127,0x00000133,0x0004003d,0x0000003b,0x00000135,0x00000123,0x000300f7,0x00000138,
+	0x00000000,0x000400fa,0x00000135,0x00000137,0x0000013a,0x000200f8,0x00000137,0x0004003d,
+	0x00000007,0x00000139,0x0000012d,0x0003003e,0x00000136,0x00000139,0x000200f9,0x00000138,
+	0x000200f8,0x0000013a,0x00050041,0x0000012e,0x0000013b,0x0000012d,0x00000024,0x0004003d,
+	0x00000006,0x0000013c,0x0000013b,0x00050085,0x00000006,0x0000013e,0x0000013c,0x0000013d,
+	0x0004003d,0x00000006,0x0000013f,0x00000127,0x00050083,0x00000006,0x00000140,0x0000013e,
+	0x0000013f,0x00050041,0x0000012e,0x00000141,0x0000012d,0x0000002b,0x0004003d,0x00000006,
+	0x00000142,0x00000141,0x00050050,0x00000007,0x00000143,0x00000140,0x00000142,0x0003003e,
+	0x00000136,0x00000143,0x000200f9,0x00000138,0x000200f8,0x00000138,0x0004003d,0x00000007,
+	0x00000144,0x00000136,0x0003003e,0x00000134,0x00000144,0x0004003d,0x0000003b,0x00000146,
+	0x00000123,0x000300f7,0x00000149,0x00000000,0x000400fa,0x00000146,0x00000148,0x0000014a,
+	0x000200f8,0x00000148,0x0003003e,0x00000147,0x0000003a,0x000200f9,0x00000149,0x000200f8,
+	0x0000014a,0x0004003d,0x00000006,0x0000014b,0x00000127,0x000500b8,0x0000003b,0x0000014c,
+	0x0000014b,0x0000003a,0x000300f7,0x0000014f,0x00000000,0x000400fa,0x0000014c,0x0000014e,
+	0x00000152,0x000200f8,0x0000014e,0x00060041,0x00000025,0x00000150,0x00000020,0x00000036,
+	0x00000024,0x0004003d,0x00000006,0x00000151,0x00000150,0x0003003e,0x0000014d,0x00000151,
+	0x000200f9,0x0000014f,0x000200f8,0x00000152,0x00060041,0x00000025,0x00000153,0x00000020,
+	0x00000036,0x00000024,0x0004003d,0x00000006,0x00000154,0x00000153,0x0004007f,0x00000006,
+	0x00000155,0x00000154,0x0003003e,0x0000014d,0x00000155,0x000200f9,0x0000014f,0x000200f8,
+	0x0000014f,0x0004003d,0x00000006,0x00000156,0x0000014d,0x00050081,0x00000006,0x00000157,
+	0x0000003a,0x00000156,0x0003003e,0x00000147,0x00000157,0x000200f9,0x00000149,0x000200f8,
+	0x00000149,0x0004003d,0x00000006,0x00000158,0x00000147,0x0003003e,0x00000145,0x00000158,
+	0x0004003d,0x00000007,0x0000015a,0x00000134,0x0004003d,0x00000006,0x0000015b,0x00000145,
+	0x00050050,0x00000007,0x0000015c,0x0000015b,0x0000003a,0x00050083,0x00000007,0x0000015d,
+	0x0000015a,0x0000015c,0x0003003e,0x00000159,0x0000015d,0x00060041,0x00000025,0x0000015f,
+	0x00000020,0x00000022,0x00000037,0x0004003d,0x00000006,0x00000160,0x0000015f,0x0003003e,
+	0x0000015e,0x00000160,0x00050041,0x00000009,0x00000162,0x00000159,0x00000024,0x0004003d,
+	0x00000006,0x00000163,0x00000162,0x00060041,0x00000025,0x00000164,0x00000020,0x00000036,
+	0x00000046,0x0004003d,0x00000006,0x00000165,0x00000164,0x00050085,0x00000006,0x00000166,
+	0x00000163,0x00000165,0x00050041,0x00000009,0x00000167,0x00000159,0x0000002b,0x0004003d,
+	0x00000006,0x00000168,0x00000167,0x00050050,0x00000007,0x00000169,0x00000166,0x00000168,
+	0x0005008e,0x00000007,0x0000016a,0x00000169,0x0000013d,0x0004003d,0x00000006,0x0000016b,
+	0x0000015e,0x0005008e,0x00000007,0x0000016c,0x0000016a,0x0000016b,0x0003003e,0x00000161,
+	0x0000016c,0x00060041,0x00000025,0x0000016d,0x00000020,0x00000022,0x00000046,0x0004003d,
+	0x00000006,0x0000016e,0x0000016d,0x000500ba,0x0000003b,0x0000016f,0x0000016e,0x0000006f,
+	0x000300f7,0x00000171,0x00000000,0x000400fa,0x0000016f,0x00000170,0x00000197,0x000200f8,
+	0x00000170,0x00060041,0x00000025,0x00000173,0x00000020,0x00000022,0x00000046,0x0004003d,
+	0x00000006,0x00000174,0x00000173,0x00050083,0x00000006,0x00000175,0x0000001c,0x00000174,
+	0x0004003d,0x00000007,0x00000177,0x00000161,0x0003003e,0x00000176,0x00000177,0x0003003e,
+	0x00000178,0x00000175,0x00060039,0x00000007,0x00000179,0x0000000d,0x00000176,0x00000178,
+	0x0003003e,0x0000017a,0x00000179,0x0004003d,0x00000006,0x0000017c,0x00000127,0x0003003e,
+	0x0000017b,0x0000017c,0x00060039,0x0000000f,0x0000017d,0x00000013,0x0000017a,0x0000017b,
+	0x00050051,0x00000006,0x0000017e,0x0000017d,0x00000000,0x00050041,0x00000009,0x0000017f,
+	0x00000172,0x00000024,0x0003003e,0x0000017f,0x0000017e,0x0004003d,0x00000007,0x00000181,
+	0x00000161,0x0003003e,0x00000180,0x00000181,0x0003003e,0x00000182,0x0000001c,0x00060039,
+	0x00000007,0x00000183,0x0000000d,0x00000180,0x00000182,0x0003003e,0x00000184,0x00000183,
+	0x0004003d,0x00000006,0x00000186,0x00000127,0x0003003e,0x00000185,0x00000186,0x00060039,
+	0x0000000f,0x00000187,0x00000013,0x00000184,0x00000185,0x00050051,0x00000006,0x00000188,
+	0x00000187,0x00000001,0x00050041,0x00000009,0x00000189,0x00000172,0x0000002b,0x0003003e,
+	0x00000189,0x00000188,0x00060041,0x00000025,0x0000018a,0x00000020,0x00000022,0x00000046,
+	0x0004003d,0x00000006,0x0000018b,0x0000018a,0x00050081,0x00000006,0x0000018c,0x0000001c,
+	0x0000018b,0x0004003d,0x00000007,0x0000018e,0x00000161,0x0003003e,0x0000018d,0x0000018e,
+	0x0003003e,0x0000018f,0x0000018c,0x00060039,0x00000007,0x00000190,0x0000000d,0x0000018d,
+	0x0000018f,0x0003003e,0x00000191,0x00000190,0x0004003d,0x00000006,0x00000193,0x00000127,
+	0x0003003e,0x00000192,0x00000193,0x00060039,0x0000000f,0x00000194,0x00000013,0x00000191,
+	0x00000192,0x00050051,0x00000006,0x00000195,0x00000194,0x00000002,0x00050041,0x00000009,
+	0x00000196,0x00000172,0x00000037,0x0003003e,0x00000196,0x00000195,0x000200f9,0x00000171,
+	0x000200f8,0x00000197,0x0004003d,0x00000007,0x00000199,0x00000161,0x0003003e,0x00000198,
+	0x00000199,0x0003003e,0x0000019a,0x0000001c,0x00060039,0x00000007,0x0000019b,0x0000000d,
+	0x00000198,0x0000019a,0x0003003e,0x0000019c,0x0000019b,0x0004003d,0x00000006,0x0000019e,
+	0x00000127,0x0003003e,0x0000019d,0x0000019e,0x00060039,0x0000000f,0x0000019f,0x00000013,
+	0x0000019c,0x0000019d,0x0003003e,0x00000172,0x0000019f,0x000200f9,0x00000171,0x000200f8,
+	0x00000171,0x0004003d,0x00000007,0x000001a1,0x00000134,0x0004003d,0x00000007,0x000001a2,
+	0x00000134,0x00050050,0x00000007,0x000001a3,0x0000001c,0x0000001c,0x00050083,0x00000007,
+	0x000001a4,0x000001a3,0x000001a2,0x0007000c,0x00000007,0x000001a5,0x00000001,0x00000025,
+	0x000001a1,0x000001a4,0x0003003e,0x000001a0,0x000001a5,0x00050041,0x00000009,0x000001a8,
+	0x000001a0,0x00000024,0x0004003d,0x00000006,0x000001a9,0x000001a8,0x00060041,0x00000025,
+	0x000001aa,0x00000020,0x00000036,0x00000046,0x0004003d,0x00000006,0x000001ab,0x000001aa,
+	0x00050085,0x00000006,0x000001ac,0x000001a9,0x000001ab,0x00050041,0x00000009,0x000001ad,
+	0x000001a0,0x0000002b,0x0004003d,0x00000006,0x000001ae,0x000001ad,0x0007000c,0x00000006,
+	0x000001af,0x00000001,0x00000025,0x000001ac,0x000001ae,0x0008000c,0x00000006,0x000001b0,
+	0x00000001,0x00000031,0x0000006f,0x000001a7,0x000001af,0x0003003e,0x000001a6,0x000001b0,
+	0x0004003d,0x0000000f,0x000001b3,0x00000172,0x0004003d,0x00000006,0x000001b4,0x000001a6,
+	0x0005008e,0x0000000f,0x000001b5,0x000001b3,0x000001b4,0x00050051,0x00000006,0x000001b6,
+	0x000001b5,0x00000000,0x00050051,0x00000006,0x000001b7,0x000001b5,0x00000001,0x00050051,
+	0x00000006,0x000001b8,0x000001b5,0x00000002,0x00070050,0x0000001d,0x000001b9,0x000001b6,
+	0x000001b7,0x000001b8,0x0000001c,0x0003003e,0x000001b2,0x000001b9,0x000100fd,0x00010038,
+	0x00050036,0x00000007,0x0000000d,0x00000000,0x0000000a,0x00030037,0x00000008,0x0000000b,
+	0x00030037,0x00000009,0x0000000c,0x000200f8,0x0000000e,0x0004003b,0x00000009,0x00000015,
+	0x00000007,0x0004003d,0x00000007,0x00000016,0x0000000b,0x0004003d,0x00000007,0x00000017,
+	0x0000000b,0x00050094,0x00000006,0x00000018,0x00000016,0x00000017,0x0003003e,0x00000015,
+	0x00000018,0x0004003d,0x00000007,0x00000019,0x0000000b,0x0004003d,0x00000006,0x0000001a,
+	0x0000000c,0x0005008e,0x00000007,0x0000001b,0x00000019,0x0000001a,0x00060041,0x00000025,
+	0x00000026,0x00000020,0x00000022,0x00000024,0x0004003d,0x00000006,0x00000027,0x00000026,
+	0x0004003d,0x00000006,0x00000028,0x00000015,0x00050085,0x00000006,0x00000029,0x00000027,
+	0x00000028,0x00050081,0x00000006,0x0000002a,0x0000001c,0x00000029,0x00060041,0x00000025,
+	0x0000002c,0x00000020,0x00000022,0x0000002b,0x0004003d,0x00000006,0x0000002d,0x0000002c,
+	0x0004003d,0x00000006,0x0000002e,0x00000015,0x00050085,0x00000006,0x0000002f,0x0000002d,
+	0x0000002e,0x0004003d,0x00000006,0x00000030,0x00000015,0x00050085,0x00000006,0x00000031,
+	0x0000002f,0x00000030,0x00050081,0x00000006,0x00000032,0x0000002a,0x00000031,0x0005008e,
+	0x00000007,0x00000033,0x0000001b,0x00000032,0x000200fe,0x00000033,0x00010038,0x00050036,
+	0x0000000f,0x00000013,0x00000000,0x00000010,0x00030037,0x00000008,0x00000011,0x00030037,
+	0x00000009,0x00000012,0x000200f8,0x00000014,0x0004003b,0x00000009,0x0000003f,0x00000007,
+	0x0004003b,0x00000008,0x00000042,0x00000007,0x0004003b,0x00000008,0x00000059,0x00000007,
+	0x0004003b,0x000000a2,0x000000a3,0x00000007,0x0004003b,0x000000bf,0x000000c0,0x00000007,
+	0x0004003b,0x000000bf,0x000000cb,0x00000007,0x0004003b,0x00000009,0x000000e4,0x00000007,
+	0x0004003b,0x000000bf,0x000000f3,0x00000007,0x0004003b,0x00000009,0x000000f9,0x00000007,
+	0x0004003b,0x00000009,0x000000fc,0x00000007,0x0004003b,0x00000008,0x00000101,0x00000007,
+	0x00060041,0x00000025,0x00000038,0x00000020,0x00000036,0x00000037,0x0004003d,0x00000006,
+	0x00000039,0x00000038,0x000500ba,0x0000003b,0x0000003c,0x00000039,0x0000003a,0x000300f7,
+	0x0000003e,0x00000000,0x000400fa,0x0000003c,0x0000003d,0x0000003e,0x000200f8,0x0000003d,
+	0x00060041,0x00000025,0x00000040,0x00000020,0x00000022,0x00000037,0x0004003d,0x00000006,
+	0x00000041,0x00000040,0x0003003e,0x0000003f,0x00000041,0x00050041,0x00000009,0x00000043,
+	0x00000011,0x00000024,0x0004003d,0x00000006,0x00000044,0x00000043,0x0004003d,0x00000006,
+	0x00000045,0x0000003f,0x00060041,0x00000025,0x00000047,0x00000020,0x00000036,0x00000046,
+	0x0004003d,0x00000006,0x00000048,0x00000047,0x00050085,0x00000006,0x00000049,0x00000045,
+	0x00000048,0x00050088,0x00000006,0x0000004a,0x00000044,0x00000049,0x00050041,0x00000009,
+	0x0000004b,0x00000011,0x0000002b,0x0004003d,0x00000006,0x0000004c,0x0000004b,0x0004003d,
+	0x00000006,0x0000004d,0x0000003f,0x00050088,0x00000006,0x0000004e,0x0000004c,0x0000004d,
+	0x00050050,0x00000007,0x0000004f,0x0000004a,0x0000004e,0x0005008e,0x00000007,0x00000050,
+	0x0000004f,0x0000003a,0x00050050,0x00000007,0x00000051,0x0000003a,0x0000003a,0x00050081,
+	0x00000007,0x00000052,0x00000050,0x00000051,0x0003003e,0x00000042,0x00000052,0x00060041,
+	0x00000025,0x00000053,0x00000020,0x00000036,0x00000037,0x0004003d,0x00000006,0x00000054,
+	0x00000053,0x000500ba,0x0000003b,0x00000056,0x00000054,0x00000055,0x000300f7,0x00000058,
+	0x00000000,0x000400fa,0x00000056,0x00000057,0x00000058,0x000200f8,0x00000057,0x00060041,
+	0x00000025,0x0000005a,0x00000020,0x00000036,0x00000046,0x0004003d,0x00000006,0x0000005b,
+	0x0000005a,0x00060041,0x00000025,0x0000005c,0x00000020,0x00000036,0x0000002b,0x0004003d,
+	0x00000006,0x0000005d,0x0000005c,0x00050088,0x00000006,0x0000005e,0x0000005b,0x0000005d,
+	0x00060041,0x00000025,0x0000005f,0x00000020,0x00000036,0x0000002b,0x0004003d,0x00000006,
+	0x00000060,0x0000005f,0x00060041,0x00000025,0x00000061,0x00000020,0x00000036,0x00000046,
+	0x0004003d,0x00000006,0x00000062,0x00000061,0x00050088,0x00000006,0x00000063,0x00000060,
+	0x00000062,0x00050050,0x00000007,0x00000064,0x0000005e,0x00000063,0x0007000c,0x00000007,
+	0x00000066,0x00000001,0x00000028,0x00000064,0x00000065,0x0003003e,0x00000059,0x00000066,
+	0x0004003d,0x00000007,0x00000067,0x00000042,0x00050050,0x00000007,0x00000068,0x0000003a,
+	0x0000003a,0x00050083,0x00000007,0x00000069,0x00000067,0x00000068,0x0004003d,0x00000007,
+	0x0000006a,0x00000059,0x00050085,0x00000007,0x0000006b,0x00000069,0x0000006a,0x00050050,
+	0x00000007,0x0000006c,0x0000003a,0x0000003a,0x00050081,0x00000007,0x0000006d,0x0000006b,
+	0x0000006c,0x0003003e,0x00000042,0x0000006d,0x0004003d,0x00000007,0x0000006e,0x00000042,
+	0x000500b8,0x00000071,0x00000072,0x0000006e,0x00000070,0x0004009a,0x0000003b,0x00000073,
+	0x00000072,0x000400a8,0x0000003b,0x00000074,0x00000073,0x000300f7,0x00000076,0x00000000,
+	0x000400fa,0x00000074,0x00000075,0x00000076,0x000200f8,0x00000075,0x0004003d,0x00000007,
+	0x00000077,0x00000042,0x000500ba,0x00000071,0x00000078,0x00000077,0x00000065,0x0004009a,
+	0x0000003b,0x00000079,0x00000078,0x000200f9,0x00000076,0x000200f8,0x00000076,0x000700f5,
+	0x0000003b,0x0000007a,0x00000073,0x00000057,0x00000079,0x00000075,0x000300f7,0x0000007c,
+	0x00000000,0x000400fa,0x0000007a,0x0000007b,0x0000007c,0x000200f8,0x0000007b,0x000200fe,
+	0x0000007d,0x000200f8,0x0000007c,0x0004003d,0x00000080,0x00000083,0x00000082,0x0004003d,
+	0x00000007,0x00000084,0x00000042,0x00050057,0x0000001d,0x00000085,0x00000083,0x00000084,
+	0x0008004f,0x0000000f,0x00000086,0x00000085,0x00000085,0x00000000,0x00000001,0x00000002,
+	0x000200fe,0x00000086,0x000200f8,0x00000058,0x0004003d,0x00000007,0x00000088,0x00000042,
+	0x000500b8,0x00000071,0x00000089,0x00000088,0x00000070,0x0004009a,0x0000003b,0x0000008a,
+	0x00000089,0x000400a8,0x0000003b,0x0000008b,0x0000008a,0x000300f7,0x0000008d,0x00000000,
+	0x000400fa,0x0000008b,0x0000008c,0x0000008d,0x000200f8,0x0000008c,0x0004003d,0x00000007,
+	0x0000008e,0x00000042,0x000500ba,0x00000071,0x0000008f,0x0000008e,0x00000065,0x0004009a,
+	0x0000003b,0x00000090,0x0000008f,0x000200f9,0x0000008d,0x000200f8,0x0000008d,0x000700f5,
+	0x0000003b,0x00000091,0x0000008a,0x00000058,0x00000090,0x0000008c,0x000300f7,0x00000093,
+	0x00000000,0x000400fa,0x00000091,0x00000092,0x00000093,0x000200f8,0x00000092,0x000200fe,
+	0x0000007d,0x000200f8,0x00000093,0x0004003d,0x00000080,0x00000095,0x00000082,0x00050041,
+	0x00000009,0x00000096,0x00000042,0x00000024,0x0004003d,0x00000006,0x00000097,0x00000096,
+	0x0004003d,0x00000006,0x00000098,0x00000012,0x00050081,0x00000006,0x00000099,0x00000097,
+	0x00000098,0x00050085,0x00000006,0x0000009a,0x00000099,0x0000003a,0x00050041,0x00000009,
+	0x0000009b,0x00000042,0x0000002b,0x0004003d,0x00000006,0x0000009c,0x0000009b,0x00050050,
+	0x00000007,0x0000009d,0x0000009a,0x0000009c,0x00050057,0x0000001d,0x0000009e,0x00000095,
+	0x0000009d,0x0008004f,0x0000000f,0x0000009f,0x0000009e,0x0000009e,0x00000000,0x00000001,
+	0x00000002,0x000200fe,0x0000009f,0x000200f8,0x0000003e,0x00050041,0x000000a5,0x000000a6,
+	0x00000020,0x000000a4,0x0004003d,0x0000001d,0x000000a7,0x000000a6,0x0008004f,0x0000000f,
+	0x000000a8,0x000000a7,0x000000a7,0x00000000,0x00000001,0x00000002,0x00050041,0x000000a5,
+	0x000000aa,0x00000020,0x000000a9,0x0004003d,0x0000001d,0x000000ab,0x000000aa,0x0008004f,
+	0x0000000f,0x000000ac,0x000000ab,0x000000ab,0x00000000,0x00000001,0x00000002,0x00050041,
+	0x000000a5,0x000000ae,0x00000020,0x000000ad,0x0004003d,0x0000001d,0x000000af,0x000000ae,
+	0x0008004f,0x0000000f,0x000000b0,0x000000af,0x000000af,0x00000000,0x00000001,0x00000002,
+	0x00050051,0x00000006,0x000000b1,0x000000a8,0x00000000,0x00050051,0x00000006,0x000000b2,
+	0x000000a8,0x00000001,0x00050051,0x00000006,0x000000b3,0x000000a8,0x00000002,0x00050051,
+	0x00000006,0x000000b4,0x000000ac,0x00000000,0x00050051,0x00000006,0x000000b5,0x000000ac,
+	0x00000001,0x00050051,0x00000006,0x000000b6,0x000000ac,0x00000002,0x00050051,0x00000006,
+	0x000000b7,0x000000b0,0x00000000,0x00050051,0x00000006,0x000000b8,0x000000b0,0x00000001,
+	0x00050051,0x00000006,0x000000b9,0x000000b0,0x00000002,0x00060050,0x0000000f,0x000000ba,
+	0x000000b1,0x000000b2,0x000000b3,0x00060050,0x0000000f,0x000000bb,0x000000b4,0x000000b5,
+	0x000000b6,0x00060050,0x0000000f,0x000000bc,0x000000b7,0x000000b8,0x000000b9,0x00060050,
+	0x000000a1,0x000000bd,0x000000ba,0x000000bb,0x000000bc,0x00040054,0x000000a1,0x000000be,
+	0x000000bd,0x0003003e,0x000000a3,0x000000be,0x0004003d,0x000000a1,0x000000c1,0x000000a3,
+	0x00050041,0x00000009,0x000000c2,0x00000011,0x00000024,0x0004003d,0x00000006,0x000000c3,
+	0x000000c2,0x00050041,0x00000009,0x000000c4,0x00000011,0x0000002b,0x0004003d,0x00000006,
+	0x000000c5,0x000000c4,0x0004007f,0x00000006,0x000000c6,0x000000c5,0x00060050,0x0000000f,
+	0x000000c8,0x000000c3,0x000000c6,0x000000c7,0x0006000c,0x0000000f,0x000000c9,0x00000001,
+	0x00000045,0x000000c8,0x00050091,0x0000000f,0x000000ca,0x000000c1,0x000000c9,0x0003003e,
+	0x000000c0,0x000000ca,0x00050041,0x000000a5,0x000000cd,0x00000020,0x000000cc,0x0004003d,
+	0x0000001d,0x000000ce,0x000000cd,0x0008004f,0x0000000f,0x000000cf,0x000000ce,0x000000ce,
+	0x00000001,0x00000002,0x00000003,0x0004003d,0x000000a1,0x000000d0,0x000000a3,0x0004003d,
+	0x00000006,0x000000d1,0x00000012,0x000500b8,0x0000003b,0x000000d2,0x000000d1,0x0000003a,
+	0x000600a9,0x00000006,0x000000d3,0x000000d2,0x000000c7,0x0000001c,0x00060041,0x00000025,
+	0x000000d4,0x00000020,0x000000a4,0x00000046,0x0004003d,0x00000006,0x000000d5,0x000000d4,
+	0x00050085,0x00000006,0x000000d6,0x000000d3,0x000000d5,0x00060050,0x0000000f,0x000000d7,
+	0x000000d6,0x0000006f,0x0000006f,0x00050091,0x0000000f,0x000000d8,0x000000d0,0x000000d7,
+	0x00050081,0x0000000f,0x000000d9,0x000000cf,0x000000d8,0x0003003e,0x000000cb,0x000000d9,
+	0x00050041,0x00000009,0x000000da,0x000000c0,0x00000037,0x0004003d,0x00000006,0x000000db,
+	0x000000da,0x000500ba,0x0000003b,0x000000dd,0x000000db,0x000000dc,0x000300f7,0x000000df,
+	0x00000000,0x000400fa,0x000000dd,0x000000de,0x000000df,0x000200f8,0x000000de,0x000200fe,
+	0x000000e2,0x000200f8,0x000000df,0x00060041,0x00000025,0x000000e5,0x00000020,0x000000a9,
+	0x00000046,0x0004003d,0x00000006,0x000000e6,0x000000e5,0x0004007f,0x00000006,0x000000e7,
+	0x000000e6,0x00050041,0x00000009,0x000000e8,0x000000cb,0x00000037,0x0004003d,0x00000006,
+	0x000000e9,0x000000e8,0x00050083,0x00000006,0x000000ea,0x000000e7,0x000000e9,0x00050041,
+	0x00000009,0x000000eb,0x000000c0,0x00000037,0x0004003d,0x00000006,0x000000ec,0x000000eb,
+	0x00050088,0x00000006,0x000000ed,0x000000ea,0x000000ec,0x0003003e,0x000000e4,0x000000ed,
+	0x0004003d,0x00000006,0x000000ee,0x000000e4,0x000500bc,0x0000003b,0x000000ef,0x000000ee,
+	0x0000006f,0x000300f7,0x000000f1,0x00000000,0x000400fa,0x000000ef,0x000000f0,0x000000f1,
+	0x000200f8,0x000000f0,0x000200fe,0x000000e2,0x000200f8,0x000000f1,0x0004003d,0x0000000f,
+	0x000000f4,0x000000cb,0x0004003d,0x0000000f,0x000000f5,0x000000c0,0x0004003d,0x00000006,
+	0x000000f6,0x000000e4,0x0005008e,0x0000000f,0x000000f7,0x000000f5,0x000000f6,0x00050081,
+	0x0000000f,0x000000f8,0x000000f4,0x000000f7,0x0003003e,0x000000f3,0x000000f8,0x00060041,
+	0x00000025,0x000000fa,0x00000020,0x000000ad,0x00000046,0x0004003d,0x00000006,0x000000fb,
+	0x000000fa,0x0003003e,0x000000f9,0x000000fb,0x0004003d,0x00000006,0x000000fd,0x000000f9,
+	0x00060041,0x00000025,0x000000fe,0x00000020,0x00000036,0x0000002b,0x0004003d,0x00000006,
+	0x000000ff,0x000000fe,0x00050088,0x00000006,0x00000100,0x000000fd,0x000000ff,0x0003003e,
+	0x000000fc,0x00000100,0x00050041,0x00000009,0x00000102,0x000000f3,0x00000024,0x0004003d,
+	0x00000006,0x00000103,0x00000102,0x0004003d,0x00000006,0x00000104,0x000000f9,0x00050088,
+	0x00000006,0x00000105,0x00000103,0x00000104,0x00050041,0x00000009,0x00000106,0x000000f3,
+	0x0000002b,0x0004003d,0x00000006,0x00000107,0x00000106,0x0004007f,0x00000006,0x00000108,
+	0x00000107,0x0004003d,0x00000006,0x00000109,0x000000fc,0x00050088,0x00000006,0x0000010a,
+	0x00000108,0x00000109,0x00050050,0x00000007,0x0000010b,0x00000105,0x0000010a,0x0005008e,
+	0x00000007,0x0000010c,0x0000010b,0x0000003a,0x00050050,0x00000007,0x0000010d,0x0000003a,
+	0x0000003a,0x00050081,0x00000007,0x0000010e,0x0000010c,0x0000010d,0x0003003e,0x00000101,
+	0x0000010e,0x0004003d,0x00000007,0x0000010f,0x00000101,0x000500b8,0x00000071,0x00000110,
+	0x0000010f,0x00000070,0x0004009a,0x0000003b,0x00000111,0x00000110,0x000400a8,0x0000003b,
+	0x00000112,0x00000111,0x000300f7,0x00000114,0x00000000,0x000400fa,0x00000112,0x00000113,
+	0x00000114,0x000200f8,0x00000113,0x0004003d,0x00000007,0x00000115,0x00000101,0x000500ba,
+	0x00000071,0x00000116,0x00000115,0x00000065,0x0004009a,0x0000003b,0x00000117,0x00000116,
+	0x000200f9,0x00000114,0x000200f8,0x00000114,0x000700f5,0x0000003b,0x00000118,0x00000111,
+	0x000000f1,0x00000117,0x00000113,0x000300f7,0x0000011a,0x00000000,0x000400fa,0x00000118,
+	0x00000119,0x0000011a,0x000200f8,0x00000119,0x000200fe,0x000000e2,0x000200f8,0x0000011a,
+	0x0004003d,0x00000080,0x0000011c,0x00000082,0x0004003d,0x00000007,0x0000011d,0x00000101,
+	0x00050057,0x0000001d,0x0000011e,0x0000011c,0x0000011d,0x0008004f,0x0000000f,0x0000011f,
+	0x0000011e,0x0000011e,0x00000000,0x00000001,0x00000002,0x000200fe,0x0000011f,0x00010038
 };

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

@@ -6,6 +6,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 #include <stdint.h>
+#include <stdatomic.h>
 #include <fcntl.h>
 #include <time.h>
 #include <stdarg.h>
@@ -271,7 +272,9 @@ volatile int g_ubwc = 1;
 
 volatile int g_no_render_node;
 
-volatile int g_output_refresh_mhz;
+static atomic_int g_output_refresh_mhz = 60000;
+static atomic_int g_output_refresh_pending;
+static int g_output_announced_refresh_mhz = 60000;
 
 volatile int g_output_w, g_output_h;
 struct pending_release {
@@ -657,6 +660,7 @@ static void take_pixel(struct surface *s, const uint8_t bgra[4], struct wl_resou
 static struct surface *g_hud_surface;
 static int64_t g_hud_last_ns, g_hud_alive_ns;
 static int g_hud_fresh;
+static uint64_t g_game_frames;
 extern void droiddeck_on_game_surface(const char *window, const char *gpu);
 extern void droiddeck_on_game_frame(void);
 extern void droiddeck_on_game_program(int pid, const char *program);
@@ -740,10 +744,12 @@ static void take_dmabuf(struct surface *s, struct dmabuf_buffer *b, struct wl_re
     }
     if (s == g_hud_surface) {
         g_hud_alive_ns = now_ns();
-        if (!repeat) { g_hud_last_ns = g_hud_alive_ns; g_hud_fresh = 1; droiddeck_on_game_frame(); }
+        if (!repeat) { g_hud_last_ns = g_hud_alive_ns; g_hud_fresh = 1; g_game_frames++; droiddeck_on_game_frame(); }
     }
 }
 
+uint64_t droiddeck_game_frames(void) { return g_game_frames; }
+
 struct dmabuf_buffer *droiddeck_dmabuf_from_resource(struct wl_resource *buffer) { return get_dmabuf(buffer); }
 int droiddeck_dmabuf_fd(const struct dmabuf_buffer *b) { return b && b->n_planes > 0 ? b->fd[0] : -1; }
 void droiddeck_dmabuf_size(const struct dmabuf_buffer *b, int *w, int *h) { *w = b->width; *h = b->height; }
@@ -794,7 +800,7 @@ static void feedback_discard_all(struct wl_list *list) {
 }
 
 static uint32_t nominal_refresh_ns(void) {
-    int mhz = g_output_refresh_mhz;
+    int mhz = atomic_load(&g_output_refresh_mhz);
     if (mhz <= 0) mhz = 60000;
     return (uint32_t)(1000000000000LL / (int64_t)mhz);
 }
@@ -1507,10 +1513,10 @@ static const struct wl_output_interface output_impl = { .release = output_releas
 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) {
+static void output_send_mode(struct wl_resource *r, int mhz) {
     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);
+                        mhz);
 }
 
 static void bind_output(struct wl_client *c, void *data, uint32_t ver, uint32_t id) {
@@ -1520,7 +1526,7 @@ static void bind_output(struct wl_client *c, void *data, uint32_t ver, uint32_t
     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);
+    output_send_mode(r, g_output_announced_refresh_mhz);
     if (ver >= WL_OUTPUT_NAME_SINCE_VERSION) {
         wl_output_send_name(r, "DroidDeck-1");
         wl_output_send_description(r, "DroidDeck display");
@@ -2835,10 +2841,19 @@ static void deliver_key(const struct input_msg *m) {
     key_event((uint32_t)m->p1, m->p2);
 }
 
-static void scroll_event(int steps) {
+static void send_axis(struct seat_pointer *sp, uint32_t t, uint32_t axis, int value120) {
+    if (!value120) return;
+    if (wl_resource_get_version(sp->ptr) >= WL_POINTER_AXIS_VALUE120_SINCE_VERSION)
+        wl_pointer_send_axis_value120(sp->ptr, axis, value120);
+    else if (wl_resource_get_version(sp->ptr) >= WL_POINTER_AXIS_DISCRETE_SINCE_VERSION && value120 % 120 == 0)
+        wl_pointer_send_axis_discrete(sp->ptr, axis, value120 / 120);
+    wl_pointer_send_axis(sp->ptr, t, axis, wl_fixed_from_double(value120 / 12.0));
+}
+
+static void axis_event(int vertical120, int horizontal120) {
     struct surface *target = g_active_constraint ? g_active_constraint->surface
                            : g_desktop ? g_desktop : (g_grab ? g_grab : toplevel_at(g_ptr_x, g_ptr_y));
-    if (!target || !steps) return;
+    if (!target || (!vertical120 && !horizontal120)) return;
     struct wl_client *client = wl_resource_get_client(target->resource);
     struct seat_pointer *sp;
     if (!pointer_for(client)) return;
@@ -2847,17 +2862,18 @@ static void scroll_event(int steps) {
     uint32_t t = now_ms();
     pointer_focus(target->resource, wl_fixed_from_double(g_ptr_x - tx), wl_fixed_from_double(g_ptr_y - ty));
     for_each_pointer_of(client, sp) {
-        if (wl_resource_get_version(sp->ptr) >= WL_POINTER_AXIS_VALUE120_SINCE_VERSION)
-            wl_pointer_send_axis_value120(sp->ptr, WL_POINTER_AXIS_VERTICAL_SCROLL, steps * 120);
-        else if (wl_resource_get_version(sp->ptr) >= WL_POINTER_AXIS_DISCRETE_SINCE_VERSION)
-            wl_pointer_send_axis_discrete(sp->ptr, WL_POINTER_AXIS_VERTICAL_SCROLL, steps);
-        wl_pointer_send_axis(sp->ptr, t, WL_POINTER_AXIS_VERTICAL_SCROLL, wl_fixed_from_int(steps * 10));
+        send_axis(sp, t, WL_POINTER_AXIS_VERTICAL_SCROLL, vertical120);
+        send_axis(sp, t, WL_POINTER_AXIS_HORIZONTAL_SCROLL, horizontal120);
         if (wl_resource_get_version(sp->ptr) >= WL_POINTER_FRAME_SINCE_VERSION)
             wl_pointer_send_frame(sp->ptr);
     }
     wl_display_flush_clients(g_display);
 }
 
+static void scroll_event(int steps) {
+    axis_event(steps * 120, 0);
+}
+
 static int update_modifiers(uint32_t evdev, int pressed) {
     static const struct { uint32_t evdev, mask; } mod_keys[] = {
         { 42, 0x1 }, { 54, 0x1 },
@@ -2913,13 +2929,19 @@ static void key_event(uint32_t evdev, int pressed) {
     wl_display_flush_clients(g_display);
 }
 
-static void output_resized(void) {
-    struct surface *s;
+static void output_notify_mode(void) {
+    int mhz = atomic_load(&g_output_refresh_mhz);
     struct wl_resource *r;
     wl_resource_for_each(r, &g_outputs) {
-        output_send_mode(r);
+        output_send_mode(r, mhz);
         if (wl_resource_get_version(r) >= 2) wl_output_send_done(r);
     }
+    g_output_announced_refresh_mhz = mhz;
+}
+
+static void output_resized(void) {
+    struct surface *s;
+    output_notify_mode();
     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);
@@ -2928,13 +2950,15 @@ static void output_resized(void) {
 
 static int on_input_readable(int fd, uint32_t mask, void *data) {
     struct input_msg m;
+    int vsync = 0;
+    int64_t vsync_ns = 0;
     while (read(fd, &m, sizeof(m)) == (ssize_t)sizeof(m)) {
         switch (m.type) {
         case 1: deliver_key(&m); break;
         case 2: pointer_event(m.p1, m.p2, 0, 0); break;
         case 3: pointer_button(m.p1, m.p2); break;
         case 4: scroll_event(m.p1); break;
-        case 5: on_vsync(((int64_t)m.p1 << 32) | (uint32_t)m.p2); break;
+        case 5: vsync = 1; vsync_ns = ((int64_t)m.p1 << 32) | (uint32_t)m.p2; break;
         case 6: pointer_delta(m.p1 / 256.0, m.p2 / 256.0); break;
         case 7: deliver_touch(&m); break;
         case 8: output_resized(); break;
@@ -2942,9 +2966,17 @@ static int on_input_readable(int fd, uint32_t mask, void *data) {
             vk_present_set_scale_mode(m.p1, m.p2);
             schedule_render();
             break;
+        case 10: break;
+        case 11: axis_event(m.p1, m.p2); break;
         default: deliver_pointer(&m); break;
         }
     }
+    if (atomic_exchange(&g_output_refresh_pending, 0) &&
+            atomic_load(&g_output_refresh_mhz) != g_output_announced_refresh_mhz) {
+        output_notify_mode();
+        wl_display_flush_clients(g_display);
+    }
+    if (vsync) on_vsync(vsync_ns);
     return 0;
 }
 
@@ -2986,6 +3018,16 @@ void droiddeck_wayland_output_resized(void) {
     (void)n;
 }
 
+void droiddeck_wayland_set_output_refresh_rate(int mhz) {
+    if (mhz <= 0) mhz = 60000;
+    if (atomic_exchange(&g_output_refresh_mhz, mhz) == mhz || g_input_pipe[1] < 0) return;
+    atomic_store(&g_output_refresh_pending, 1);
+    struct input_msg m = { 10, 0, 0, 0, 0 };
+    ssize_t n;
+    do { n = write(g_input_pipe[1], &m, sizeof(m)); } while (n < 0 && errno == EINTR);
+    (void)n;
+}
+
 void droiddeck_wayland_vsync(int64_t frame_time_ns) {
     if (g_input_pipe[1] < 0) return;
     struct input_msg m = { 5, (int)(frame_time_ns >> 32), (int)(uint32_t)frame_time_ns, 0, 0 };
@@ -3223,6 +3265,7 @@ int droiddeck_wayland_run(void) {
     if ((g_stats_timer = wl_event_loop_add_timer(wl_display_get_event_loop(display), on_stats_timer, NULL)))
         wl_event_source_timer_update(g_stats_timer, 10000);
 
+    g_output_announced_refresh_mhz = atomic_load(&g_output_refresh_mhz);
     wl_display_run(display);
 
     wl_display_destroy(display);

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

@@ -11,6 +11,7 @@
 #include <android/log.h>
 
 void droiddeck_log(const char *tag, const char *fmt, ...) __attribute__((format(printf, 2, 3)));
+uint64_t droiddeck_game_frames(void);
 #define FGLOG(...) droiddeck_log("framegen", __VA_ARGS__)
 #define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, "DroidDeckWayland", __VA_ARGS__)
 
@@ -372,7 +373,11 @@ int vkp_framegen_run(VkCommandBuffer cmd, VkImage scene, VkImageView scene_view,
         return 0;
     }
 
-    uint32_t n_gen = fge_plan(g_ring_n, ++g_source_frames, g_presented_rate);
+    /* The pacer's source rate must be the game's, not this loop's: a loop slowed by its own
+     * generations would otherwise read as a slower game and justify even more generations. */
+    ++g_source_frames;
+    const uint64_t game_frames = droiddeck_game_frames();
+    uint32_t n_gen = fge_plan(g_ring_n, game_frames ? game_frames : g_source_frames, g_presented_rate);
     if (n_gen > g_ring_n) n_gen = g_ring_n;
     g_planned = n_gen;
 

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

@@ -9,6 +9,7 @@
 enum {
     DROIDDECK_HEADPOSE_LIVE = 1u << 0,
     DROIDDECK_HEADPOSE_ENABLED = 1u << 1,
+    DROIDDECK_HEADPOSE_MONO = 1u << 2,
 };
 
 struct droiddeck_headpose {
@@ -22,7 +23,10 @@ struct droiddeck_headpose {
     float tan_half_fov;
     float eye_aspect;
     uint32_t eye_w, eye_h;
-    uint32_t reserved[12];
+    float display_hz;
+    // Uses a formerly reserved word; older publishers leave this zero.
+    uint32_t render_height;
+    uint32_t reserved[10];
 };
 
 #ifdef __cplusplus

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

@@ -0,0 +1,59 @@
+#define _POSIX_C_SOURCE 200809L
+#include "spatialpose_shm.h"
+#include <jni.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <stdatomic.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+static pthread_mutex_t spatial_lock = PTHREAD_MUTEX_INITIALIZER;
+static struct droiddeck_spatialpose *shared;
+
+JNIEXPORT jboolean JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetSpatialFile(
+        JNIEnv *env, jclass clazz, jstring path) {
+    (void)clazz;
+    pthread_mutex_lock(&spatial_lock);
+    if (!shared && path) {
+        const char *name = (*env)->GetStringUTFChars(env, path, NULL);
+        if (name) {
+            int fd = open(name, O_RDWR | O_CREAT | O_CLOEXEC, 0600);
+            (*env)->ReleaseStringUTFChars(env, path, name);
+            if (fd >= 0) {
+                if (ftruncate(fd, sizeof(*shared)) == 0) {
+                    void *p = mmap(NULL, sizeof(*shared), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+                    if (p != MAP_FAILED) {
+                        shared = p;
+                        memset(shared, 0, sizeof(*shared));
+                        shared->magic = DROIDDECK_SPATIALPOSE_MAGIC;
+                        shared->version = DROIDDECK_SPATIALPOSE_VERSION;
+                        shared->size = sizeof(*shared);
+                    }
+                }
+                close(fd);
+            }
+        }
+    }
+    jboolean ready = shared != NULL;
+    pthread_mutex_unlock(&spatial_lock);
+    return ready;
+}
+
+JNIEXPORT void JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativePublishSpatial(
+        JNIEnv *env, jclass clazz, jobject buffer) {
+    (void)clazz;
+    if (!buffer || (*env)->GetDirectBufferCapacity(env, buffer) != sizeof(*shared)) return;
+    const struct droiddeck_spatialpose *src = (*env)->GetDirectBufferAddress(env, buffer);
+    if (!src || src->magic != DROIDDECK_SPATIALPOSE_MAGIC || src->version != DROIDDECK_SPATIALPOSE_VERSION ||
+        src->size != sizeof(*shared)) return;
+    pthread_mutex_lock(&spatial_lock);
+    if (shared) {
+        unsigned seq = __atomic_load_n(&shared->seq, __ATOMIC_RELAXED);
+        __atomic_store_n(&shared->seq, seq | 1u, __ATOMIC_RELAXED);
+        __atomic_thread_fence(__ATOMIC_RELEASE);
+        memcpy((char *)shared + 16, (const char *)src + 16, sizeof(*shared) - 16);
+        __atomic_store_n(&shared->seq, (seq | 1u) + 1u, __ATOMIC_RELEASE);
+    }
+    pthread_mutex_unlock(&spatial_lock);
+}

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

@@ -0,0 +1,33 @@
+#ifndef DROIDDECK_SPATIALPOSE_SHM_H
+#define DROIDDECK_SPATIALPOSE_SHM_H
+#include <stdint.h>
+#define DROIDDECK_SPATIALPOSE_MAGIC 0x53504444u
+#define DROIDDECK_SPATIALPOSE_VERSION 4u
+#define DROIDDECK_SPATIALPOSE_FILE "droiddeck-spatialpose"
+enum { DD_SPATIAL_ACTIVE = 1u, DD_SPATIAL_HANDS = 2u, DD_SPATIAL_JOYCONS = 4u, DD_SPATIAL_STEADY_AIM = 8u, DD_SPATIAL_VALID = 1u };
+enum { DD_SPATIAL_TRIGGER_VALID = 2u, DD_SPATIAL_GRIP_VALID = 4u };
+struct dd_spatial_pose {
+    int64_t time_ns;
+    float position[3];
+    float rotation[4];
+    uint32_t flags;
+};
+struct dd_spatial_hand {
+    struct dd_spatial_pose pose;
+    float trigger;
+    uint32_t grip;
+};
+struct droiddeck_spatialpose {
+    uint32_t magic, version, size, seq;
+    uint64_t connection, origin;
+    uint32_t flags, input_epochs;
+    struct dd_spatial_pose head;
+    struct dd_spatial_hand hands[2];
+};
+#ifdef __cplusplus
+static_assert(sizeof(dd_spatial_pose) == 40, "spatial pose ABI");
+static_assert(sizeof(droiddeck_spatialpose) == 176, "spatial snapshot ABI");
+#else
+_Static_assert(sizeof(struct droiddeck_spatialpose) == 176, "spatial snapshot ABI");
+#endif
+#endif

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

@@ -27,13 +27,13 @@ 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 void droiddeck_wayland_set_output_refresh_rate(int mhz);
 extern volatile int g_fps_limit;
 extern volatile int g_hide_shell;
 extern volatile int g_zero_copy;
 extern volatile unsigned g_zero_copy_last;
 extern volatile int g_ubwc;
 extern volatile int g_no_render_node;
-extern volatile int g_output_refresh_mhz;
 extern volatile int g_output_w, g_output_h;
 
 #define TAG "DroidDeckWayland"
@@ -328,7 +328,7 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetLayerFrameRate(JN
 
 JNIEXPORT void JNICALL
 Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetOutputRefreshRate(JNIEnv *env, jclass clazz, jfloat hz) {
-    g_output_refresh_mhz = hz > 1.0f ? (int)(hz * 1000.0f + 0.5f) : 0;
+    droiddeck_wayland_set_output_refresh_rate(hz > 1.0f ? (int)(hz * 1000.0f + 0.5f) : 0);
 }
 
 extern void vkp_reset_first_frame(void);
@@ -342,6 +342,7 @@ JNIEXPORT void JNICALL
 Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetOutputSize(JNIEnv *env, jclass clazz, jint w, jint h) {
     g_output_w = w > 0 ? w : 0;
     g_output_h = h > 0 ? h : 0;
+    vkp_cardboard_set_render_height(h);
 }
 
 JNIEXPORT void JNICALL
@@ -350,6 +351,7 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeResizeOutput(JNIEnv
     if (w <= 0 || h <= 0) return;
     g_output_w = w;
     g_output_h = h;
+    vkp_cardboard_set_render_height(h);
     droiddeck_wayland_output_resized();
 }
 
@@ -402,10 +404,11 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetScreenEffects(JNI
 
 JNIEXPORT void JNICALL
 Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetCardboard(JNIEnv *env, jclass clazz, jboolean enabled,
-        jint source, jfloat ipd, jfloat dist, jfloat width, jfloat k1, jfloat k2, jfloat fov, jfloat inset, jfloat chroma) {
+        jint source, jfloat ipd, jfloat dist, jfloat width, jfloat k1, jfloat k2, jfloat fov, jfloat inset, jfloat chroma,
+        jboolean mono, jfloat hz) {
     struct cardboard_params p = {.enabled = enabled ? 1 : 0, .source = source, .ipd_m = ipd, .screen_dist_m = dist,
                                  .screen_width_m = width, .k1 = k1, .k2 = k2, .fov_deg = fov, .lens_inset = inset,
-                                 .chroma = chroma};
+                                 .chroma = chroma, .mono = mono ? 1 : 0, .display_hz = hz};
     vkp_cardboard_set(&p);
 }
 
@@ -646,3 +649,14 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeRaisePriority(JNIEnv
     int after = getpriority(PRIO_PROCESS, (id_t)tid);
     return after == -1 && errno != 0 ? 100 : after;
 }
+
+JNIEXPORT void JNICALL
+Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetCardboardSpatialPose(JNIEnv *env, jclass clazz,
+        jfloatArray rot, jfloatArray pos, jboolean live) {
+    (void)clazz;
+    if (!rot || !pos || (*env)->GetArrayLength(env, rot) != 9 || (*env)->GetArrayLength(env, pos) != 3) return;
+    float m[9], p[3];
+    (*env)->GetFloatArrayRegion(env, rot, 0, 9, m);
+    (*env)->GetFloatArrayRegion(env, pos, 0, 3, p);
+    vkp_cardboard_set_spatial_pose(m, p, live ? 1 : 0);
+}

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

@@ -16,11 +16,19 @@ class App : Application() {
 
     override fun onCreate() {
         super.onCreate()
+        // Helper processes must not initialize the main USB provider or guest graphics context.
+        val process = if (android.os.Build.VERSION.SDK_INT >= 28) Application.getProcessName()
+            else (getSystemService(ACTIVITY_SERVICE) as android.app.ActivityManager)
+                .runningAppProcesses?.firstOrNull { it.pid == android.os.Process.myPid() }?.processName
+        if (process == "$packageName:vr_recovery" || process == "$packageName:rgb_diagnostic") return
         CrashHandler.install(this)
         com.droiddeck.launcher.session.QuestExperimental.initialize(this)
         com.droiddeck.launcher.session.SessionPrefs.settleGpuDriverMode(this)
         com.droiddeck.launcher.update.AppUpdates.init(this)
+        com.droiddeck.launcher.core.DownloadSource.init(this)
         GpuClockPin.clearLeftover(this)
+        com.droiddeck.launcher.glasses.Glasses.init(this)
+        com.droiddeck.launcher.glasses.GlassesMenuMirror.initialize(this)
         BwrapSpawner.start(this)
         com.droiddeck.launcher.frontend.GameFileSync.start(this)
         com.droiddeck.launcher.stores.StoresState.init(this)

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

@@ -11,6 +11,7 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.mutableIntStateOf
+import com.droiddeck.launcher.gpu.AutoDriverTrial
 import com.droiddeck.launcher.gpu.DriverBundle
 import com.droiddeck.launcher.gpu.DriverPairs
 import com.droiddeck.launcher.gpu.GpuInfo
@@ -21,7 +22,12 @@ import com.droiddeck.launcher.gpu.TurnipReleases
 import com.droiddeck.launcher.session.SessionService
 import com.droiddeck.launcher.session.SessionPrefs
 import com.droiddeck.launcher.session.QuestExperimental
+import com.droiddeck.launcher.session.SessionState
 import com.droiddeck.launcher.ui.DriverRow
+import com.droiddeck.launcher.ui.DriverSlot
+import com.droiddeck.launcher.ui.GPU_MODE_AUTO
+import com.droiddeck.launcher.ui.GPU_MODE_MIX
+import com.droiddeck.launcher.ui.GPU_MODE_PAIR
 import com.droiddeck.launcher.ui.GpuDriversState
 import com.droiddeck.launcher.ui.PairRow
 import com.droiddeck.launcher.wayland.CompositorHost
@@ -42,7 +48,18 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
     var pairPercent by mutableIntStateOf(-1)
     var autoStatus by mutableStateOf("")
     var activeBundle by mutableStateOf<String?>(null)
-    private var autoCheckedThisProcess = false
+    private var lastAutoCheck = 0L
+    private var pairModeOpen by mutableStateOf(false)
+    var restartPending by mutableStateOf(false)
+        private set
+    private var runtimePending by mutableStateOf(false)
+    private var sessionRunning by mutableStateOf(false)
+
+    val uiMode: String get() = when (mode) {
+        SessionPrefs.GPU_DRIVERS_AUTO -> GPU_MODE_AUTO
+        SessionPrefs.GPU_DRIVERS_MIX -> GPU_MODE_MIX
+        else -> if (pairModeOpen || pairRows.any { it.active }) GPU_MODE_PAIR else GPU_MODE_MIX
+    }
 
     fun state() = GpuDriversState(
         gpuName = gpu.displayName(activity), gpuFamily = gpu.family.label(activity), soc = gpu.soc, supportText = gpu.supportText(activity),
@@ -52,7 +69,56 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
         linuxRows = linuxRows, linuxSelected = linuxSelected, androidRows = androidRows, androidSelected = androidSelected,
         linuxDownloads = linuxDownloads, androidDownloads = androidDownloads, canRestoreBundled = canRestoreBundled,
         activeBundle = activeBundle,
+        mode = uiMode, display = displaySlot(), runtime = runtimeSlot(),
+        canRestart = !sessionRunning,
+        checkedAt = TurnipReleases.cached(activity)?.checkedAt ?: 0L,
     )
+
+    private fun slotSource(chosenDefault: Boolean, defaultLabel: Int): String = activity.getString(when {
+        uiMode == GPU_MODE_AUTO -> R.string.gpu_src_auto
+        uiMode == GPU_MODE_PAIR && pairRows.any { it.active } -> R.string.gpu_src_pair
+        activeBundle != null -> R.string.gpu_src_bundle
+        chosenDefault -> defaultLabel
+        else -> R.string.gpu_src_chosen
+    })
+
+    private fun displaySlot(): DriverSlot {
+        val row = androidRows.firstOrNull { it.id == androidSelected }
+        val live = androidRows.firstOrNull { it.id == CompositorHost.displayChoice }?.name
+        return DriverSlot(
+            name = row?.name ?: activity.getString(R.string.gpu_auto_by_gpu),
+            source = slotSource(androidSelected == TurnipDriver.AUTO, R.string.gpu_src_by_gpu),
+            pending = restartPending,
+            status = when {
+                restartPending -> activity.getString(R.string.gpu_display_pending, live ?: activity.getString(R.string.gpu_previous_driver))
+                CompositorHost.isStarted -> activity.getString(R.string.gpu_display_live)
+                else -> activity.getString(R.string.gpu_display_next)
+            },
+        )
+    }
+
+    private fun runtimeSlot(): DriverSlot {
+        val row = linuxRows.firstOrNull { it.id == linuxSelected }
+        val live = SessionState.runtimeDriver?.let { id -> linuxRows.firstOrNull { it.id == id }?.name }
+        return DriverSlot(
+            name = row?.name ?: activity.getString(R.string.gpu_runtime_default),
+            source = slotSource(linuxSelected.isEmpty(), R.string.gpu_src_default),
+            pending = runtimePending,
+            status = when {
+                runtimePending -> activity.getString(R.string.gpu_runtime_pending, live ?: activity.getString(R.string.gpu_previous_driver))
+                sessionRunning -> activity.getString(R.string.gpu_runtime_live)
+                else -> activity.getString(R.string.gpu_runtime_hint)
+            },
+        )
+    }
+
+    fun restartApp() {
+        if (SessionState.running) return
+        val launch = activity.packageManager.getLaunchIntentForPackage(activity.packageName) ?: return
+        activity.startActivity(android.content.Intent.makeRestartActivityTask(launch.component)
+            .putExtra(com.droiddeck.launcher.stores.download.StoreDownloadService.EXTRA_NAV, "components"))
+        Runtime.getRuntime().exit(0)
+    }
     var androidRows by mutableStateOf<List<DriverRow>>(emptyList())
     var androidSelected by mutableStateOf("")
 
@@ -90,14 +156,23 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
         canRestoreBundled = td.hiddenBundled().isNotEmpty()
         androidSelected = SessionPrefs.androidDriver(activity)
         activeBundle = DriverBundle.active(activity)?.label
+        restartPending = CompositorHost.isStarted && CompositorHost.displayChoice.let { it != null && it != androidSelected }
+        sessionRunning = SessionState.running
+        runtimePending = sessionRunning && SessionState.runtimeDriver.let { it != null && it != linuxSelected }
         refreshReleaseRows()
         refreshPairs()
     }
 
     fun summary(): String {
         val active = pairRows.firstOrNull { it.active }?.name ?: activeBundle
-        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
+        val display = displaySlot().name
+        val base = when {
+            uiMode == GPU_MODE_AUTO -> activity.getString(R.string.drivers_summary, activity.getString(R.string.common_auto), active ?: display)
+            uiMode == GPU_MODE_PAIR && active != null -> activity.getString(R.string.drivers_summary, activity.getString(R.string.gpu_mode_pair_short), active)
+            else -> activity.getString(R.string.drivers_summary, activity.getString(R.string.gpu_mode_mix_short),
+                runtimeSlot().name.let { if (it == display) it else activity.getString(R.string.gpu_summary_mix, display, it) })
+        }
+        return if (restartPending) activity.getString(R.string.gpu_summary_restart, base) else base
     }
 
     fun refreshPairs() {
@@ -121,18 +196,48 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
         }.sortedByDescending { it.recommended }
     }
 
-    fun setMode(auto: Boolean) {
-        mode = if (auto) SessionPrefs.GPU_DRIVERS_AUTO else SessionPrefs.GPU_DRIVERS_MANUAL
+    fun chooseMode(next: String) {
+        pairModeOpen = next == GPU_MODE_PAIR
+        setMode(auto = next == GPU_MODE_AUTO, mix = next == GPU_MODE_MIX)
+    }
+
+    fun setMode(auto: Boolean, mix: Boolean = false) {
+        mode = when {
+            auto -> SessionPrefs.GPU_DRIVERS_AUTO
+            mix -> SessionPrefs.GPU_DRIVERS_MIX
+            else -> SessionPrefs.GPU_DRIVERS_MANUAL
+        }
         SessionPrefs.setGpuDriverMode(activity, mode)
         autoStatus = ""
         if (auto) ensureAuto(force = false)
     }
 
+    fun checkOnOpen() {
+        if (SessionPrefs.gpuDriverMode(activity) == SessionPrefs.GPU_DRIVERS_AUTO) ensureAuto(force = false)
+        else if (!releaseChecking && releasesStale() && com.droiddeck.launcher.frontend.AutoComponents.isOnline(activity)) checkLatestTurnip()
+    }
+
+    private fun releasesStale(): Boolean {
+        val cached = TurnipReleases.cached(activity)
+        return cached == null || System.currentTimeMillis() - cached.checkedAt > RELEASE_CHECK_INTERVAL_MS ||
+            cached.assets.none { it.pair.isNotEmpty() }
+    }
+
     fun ensureAuto(force: Boolean) {
         mode = SessionPrefs.gpuDriverMode(activity)
         if (mode != SessionPrefs.GPU_DRIVERS_AUTO || pairBusy != null || releaseChecking) return
-        if (!force && autoCheckedThisProcess) return
-        autoCheckedThisProcess = true
+        if (SessionState.running) {
+            if (force) autoStatus = activity.getString(R.string.drivers_auto_waits_for_session)
+            return
+        }
+        AutoDriverTrial.rollbackDue(activity)?.let { trial ->
+            AutoDriverTrial.rollBack(activity, trial)
+            autoStatus = activity.getString(R.string.drivers_rolled_back, trial.name)
+            refreshDrivers()
+            return
+        }
+        if (!force && System.currentTimeMillis() - lastAutoCheck < RELEASE_CHECK_INTERVAL_MS) return
+        lastAutoCheck = System.currentTimeMillis()
         val displayChanged = SessionPrefs.androidDriver(activity) != QuestExperimental.defaultAndroidDriver()
         if (QuestExperimental.applyAutoDrivers(activity)) {
             autoStatus = activity.getString(
@@ -148,10 +253,8 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
         releaseChecking = true
         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 ||
-                cached.assets.none { it.pair.isNotEmpty() }
-            val problem = if (force || stale) runCatching { TurnipReleases.refresh(activity) }.exceptionOrNull()?.message else null
+            val problem = if (force || releasesStale()) runCatching { TurnipReleases.refresh(activity) }.exceptionOrNull()?.message else null
+            val holdBack = !force && com.droiddeck.launcher.frontend.AutoComponents.constrained(activity)
             ui.post {
                 releaseChecking = false
                 refreshReleaseRows()
@@ -165,6 +268,10 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
                         ?: activity.getString(R.string.upd_current_status)
                     pair == null || !pair.complete ->
                         autoStatus = problem?.let { activity.getString(R.string.upd_couldnt_check, it) } ?: activity.getString(R.string.drivers_recommended_unpublished)
+                    AutoDriverTrial.release(pair) in AutoDriverTrial.bad(activity) ->
+                        autoStatus = activity.getString(R.string.drivers_skipping_bad, pair.name, pair.version)
+                    SessionState.running -> autoStatus = activity.getString(R.string.drivers_auto_waits_for_session)
+                    holdBack && row?.installed != true -> autoStatus = activity.getString(R.string.drivers_auto_waits_for_network, pair.name, pair.version)
                     else -> installPair(pair, auto = true)
                 }
             }
@@ -174,6 +281,8 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
     fun selectPair(key: String) {
         if (pairBusy != null) return
         val pair = DriverPairs.from(TurnipReleases.cached(activity)).firstOrNull { it.key == key && it.complete } ?: return
+        pairModeOpen = true
+        if (mode != SessionPrefs.GPU_DRIVERS_MANUAL) setMode(auto = false)
         installPair(pair, auto = false)
     }
 
@@ -183,8 +292,6 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
         pairPercent = 0
         if (auto) autoStatus = activity.getString(R.string.drivers_downloading_pair, pair.name, pair.version)
         Thread({
-            val lm = LinuxVulkanDriverManager(activity)
-            val td = TurnipDriver(activity)
             var downloaded = false
             val result = runCatching {
                 val zips = pair.assets
@@ -198,22 +305,27 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
                 pairBusy = null
                 pairPercent = -1
                 result.onSuccess { (displayId, linuxId) ->
-                    val displayChanged = SessionPrefs.androidDriver(activity) != displayId
+                    if (auto && SessionState.running) {
+                        lastAutoCheck = 0L
+                        autoStatus = activity.getString(R.string.drivers_auto_waits_for_session)
+                        return@onSuccess
+                    }
+                    val previousDisplay = SessionPrefs.androidDriver(activity)
+                    val previousLinux = SessionPrefs.linuxDriver(activity)
+                    val displayChanged = previousDisplay != displayId
                     SessionPrefs.setAndroidDriver(activity, displayId)
                     SessionPrefs.setLinuxDriver(activity, linuxId)
                     val restart = displayChanged && CompositorHost.isStarted
                     if (auto) {
-                        val previous = SessionPrefs.gpuAutoInstalled(activity)
-                        for (id in previous - setOf(displayId, linuxId)) {
-                            val bundle = DriverBundle.containing(activity, id, lm.isInstalled(id))
-                            when {
-                                bundle != null -> { DriverBundle.remove(activity, bundle); TurnipReleases.forget(activity, bundle.id) }
-                                lm.isInstalled(id) -> lm.removeDriver(id)
-                                else -> td.remove(id)
-                            }
-                            TurnipReleases.forget(activity, id)
-                        }
-                        SessionPrefs.setGpuAutoInstalled(activity, setOf(displayId, linuxId))
+                        val trial = AutoDriverTrial.current(activity)
+                        val lastGood = trial?.let { setOf(it.previousDisplay, it.previousLinux) } ?: setOf(previousDisplay, previousLinux)
+                        val changed = previousDisplay != displayId || previousLinux != linuxId
+                        SessionPrefs.setGpuAutoInstalled(activity, SessionPrefs.gpuAutoInstalled(activity) + setOf(displayId, linuxId))
+                        if (changed) AutoDriverTrial.begin(
+                            activity, AutoDriverTrial.release(pair), "${pair.name} ${pair.version}", displayId, linuxId,
+                            trial?.previousDisplay ?: previousDisplay, trial?.previousLinux ?: previousLinux,
+                        )
+                        if (!SessionState.running) AutoDriverTrial.prune(activity, lastGood + setOf(displayId, linuxId))
                         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 },
@@ -304,14 +416,15 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
             linux -> SessionPrefs.setLinuxDriver(activity, id)
             else -> SessionPrefs.setAndroidDriver(activity, id)
         }
-        setMode(false)
+        pairModeOpen = false
+        setMode(auto = false, mix = true)
         refreshDrivers()
     }
 
     private fun useBundle(bundle: DriverBundle.Bundle): String {
         val displayChanged = SessionPrefs.androidDriver(activity) != bundle.androidId
         DriverBundle.select(activity, bundle)
-        if (mode == SessionPrefs.GPU_DRIVERS_AUTO) setMode(false)
+        if (mode == SessionPrefs.GPU_DRIVERS_AUTO) setMode(auto = false, mix = true)
         return activity.getString(
             if (displayChanged && CompositorHost.isStarted) R.string.drivers_using_bundle_restart else R.string.drivers_using_bundle,
             bundle.label,
@@ -420,6 +533,7 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
 
     private companion object {
         const val TAG = "MainActivity"
+        const val RELEASE_CHECK_INTERVAL_MS = 3_600_000L
     }
 }
 

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

@@ -47,6 +47,7 @@ import com.droiddeck.launcher.session.SessionLogShare
 import com.droiddeck.launcher.session.SessionPrefs
 import com.droiddeck.launcher.session.SteamRepair
 import com.droiddeck.launcher.core.CpuCores
+import com.droiddeck.launcher.core.DownloadSource
 import com.droiddeck.launcher.core.PhantomProcessLimit
 import com.droiddeck.launcher.core.PhantomProcessStatus
 import com.droiddeck.launcher.core.WirelessAdbFix
@@ -108,7 +109,12 @@ class MainActivity : ComponentActivity() {
     private var frameGenLabel by mutableStateOf("")
     private var lossless by mutableStateOf(Lossless.State.NONE)
     private var showRemove by mutableStateOf(false)
+    private var pendingSwitch by mutableStateOf<Intent?>(null)
+    private var switchingTo: Intent? = null
+    private var switchPoll: Runnable? = null
+    private var switchDeadline = 0L
     private var showResetSettings by mutableStateOf(false)
+    private var lowSpace by mutableStateOf<Long?>(null)
     private var showNonAdreno by mutableStateOf<LinuxRuntimeInstaller.Release?>(null)
     private var glThread by mutableStateOf(true)
     private var noGlError by mutableStateOf(true)
@@ -154,6 +160,9 @@ class MainActivity : ComponentActivity() {
     private var stretch16x9 by mutableStateOf(false)
     private var orientation by mutableStateOf(android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE)
     private var launcherFullscreen by mutableStateOf(true)
+    private var downloadSource by mutableStateOf(DownloadSource.MODE_AUTO)
+    private var downloadMirror by mutableStateOf("")
+    private var downloadPrefix by mutableStateOf("")
     private var animationsEnabled by mutableStateOf(true)
     private var gameStoresEnabled by mutableStateOf(true)
     private var gameStoresSpeedTier by mutableStateOf("fast")
@@ -187,6 +196,10 @@ class MainActivity : ComponentActivity() {
         SessionPrefs.setWifiDiscoveryEnabled(this, WifiDiscovery.permissionGranted(this))
         refreshWifiDiscovery()
     }
+    private val cameraPermission = registerForActivityResult(ActivityResultContracts.RequestPermission()) {
+        com.droiddeck.launcher.handtracking.HandTracking.refreshPermission(this)
+    }
+    private var placementCheck by mutableStateOf<Boolean?>(null)
     private val wifiPermissionSettings = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
         SessionPrefs.setWifiDiscoveryEnabled(this, WifiDiscovery.permissionGranted(this))
         refreshWifiDiscovery()
@@ -204,6 +217,9 @@ class MainActivity : ComponentActivity() {
     private val pickDeckyPluginZip = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r ->
         if (r.resultCode == RESULT_OK) InAppFilePicker.pickedFile(r.data)?.let { decky.importPluginZip(it) }
     }
+    private val pickBootMovie = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r ->
+        if (r.resultCode == RESULT_OK) InAppFilePicker.pickedFile(r.data)?.let { importBootMovie(it) }
+    }
     private val pickAnyDriver = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r ->
         if (r.resultCode == RESULT_OK) InAppFilePicker.pickedUri(r.data)?.let { drivers.importDriver(it, linux = null) }
     }
@@ -248,6 +264,38 @@ class MainActivity : ComponentActivity() {
         }, "lossless-sync").start()
     }
 
+    private fun importBootMovie(file: File) {
+        bootMovieImporting = true
+        bootMovieProgress = -1
+        Thread({
+            val result = com.droiddeck.launcher.session.BootMovie.import(
+                this, file,
+                onStart = { ui.post { android.widget.Toast.makeText(this, getString(R.string.boot_movie_converting_started, file.name), android.widget.Toast.LENGTH_LONG).show() } },
+                onProgress = { percent -> ui.post { bootMovieProgress = percent } },
+            )
+            val message = when (result) {
+                is com.droiddeck.launcher.session.BootMovie.Import.Done -> getString(
+                    if (result.audioDropped) R.string.boot_movie_imported_silent else R.string.boot_movie_imported, result.name)
+                com.droiddeck.launcher.session.BootMovie.Import.TooLong ->
+                    getString(R.string.boot_movie_too_long, com.droiddeck.launcher.session.BootMovie.MAX_CONVERT_SECONDS)
+                is com.droiddeck.launcher.session.BootMovie.Import.Unsupported -> getString(R.string.boot_movie_unsupported)
+                com.droiddeck.launcher.session.BootMovie.Import.Failed -> getString(R.string.boot_movie_import_failed)
+            }
+            ui.post {
+                bootMovieImporting = false
+                bootMovieProgress = -1
+                loadBootMovie()
+                android.widget.Toast.makeText(this, message, android.widget.Toast.LENGTH_LONG).show()
+            }
+        }, "boot-movie-import").start()
+    }
+
+    private fun loadBootMovie() {
+        bootMovie = com.droiddeck.launcher.session.BootMovie.choice(this)
+        bootMovieSound = SessionPrefs.bootMovieSound(this)
+        bootMovieCustomName = com.droiddeck.launcher.session.BootMovie.customName(this)
+    }
+
     private fun importLossless(dll: File) {
         Thread({
             val message = Lossless.message(this, Lossless.import(this, dll))
@@ -323,7 +371,13 @@ class MainActivity : ComponentActivity() {
     private var resolution by mutableStateOf(com.droiddeck.launcher.session.SessionDisplay.DEFAULT_RESOLUTION)
     private var fexPreset by mutableStateOf("")
     private var forceSsbs by mutableStateOf(false)
+    private var steamClientArch by mutableStateOf("arm64")
     private var runSteamAtStartup by mutableStateOf(false)
+    private var bootMovie by mutableStateOf(com.droiddeck.launcher.session.BootMovie.DROIDDECK_30)
+    private var bootMovieSound by mutableStateOf(true)
+    private var bootMovieCustomName by mutableStateOf<String?>(null)
+    private var bootMovieImporting by mutableStateOf(false)
+    private var bootMovieProgress by mutableStateOf(-1)
     private var theme by mutableStateOf("graphite")
     private var appScale by mutableStateOf(com.droiddeck.launcher.core.AppUiPrefs.DEFAULT_SCALE)
     private var hdrOn by mutableStateOf(false)
@@ -346,11 +400,13 @@ class MainActivity : ComponentActivity() {
     }
     private var romsDir by mutableStateOf<String?>(null)
     private var steamGames by mutableStateOf<List<Library.SteamGame>>(emptyList())
+    private var steamGamesX64 by mutableStateOf(false)
     @Volatile private var componentSweepDone = false
     @Volatile private var componentSweepSession: String? = null
     private var emulatorList by mutableStateOf<List<Library.Emulator>>(emptyList())
     private var runningLabel by mutableStateOf<String?>(null)
     private var logsEnabled by mutableStateOf(true)
+    private var vacDiagnostics by mutableStateOf(false)
     private var agentCommands by mutableStateOf(false)
     private var showRoms by mutableStateOf(false)
     private var homeAppSelected by mutableStateOf(false)
@@ -457,24 +513,186 @@ class MainActivity : ComponentActivity() {
             android.widget.Toast.makeText(this, R.string.main_wait_install_game, android.widget.Toast.LENGTH_SHORT).show()
             return false
         }
+        if (com.droiddeck.launcher.session.NoSteamLaunch.enabled(this, game)) return launchWithoutSteam(game, returnHome)
         if (SessionState.running) {
             if (SessionState.mode != SessionService.MODE_STEAM || SessionState.stopRequested) {
                 android.widget.Toast.makeText(this, R.string.game_link_session_busy, android.widget.Toast.LENGTH_LONG).show()
                 return true
             }
-            if (!SessionService.launchGame(this, game.gameIdString)) {
+            val steamVr = game.gameIdString == com.droiddeck.launcher.gpu.SteamVr.APP_ID
+            if (!steamVr && !SessionService.launchGame(this, game.gameIdString)) {
                 android.widget.Toast.makeText(this, R.string.game_link_failed, android.widget.Toast.LENGTH_LONG).show()
                 return false
             }
             startActivity(Intent(this, SessionActivity::class.java).setAction(SessionService.ACTION_RESUME)
+                .putExtra(SessionActivity.EXTRA_STEAMVR, steamVr)
                 .putExtra(SessionActivity.EXTRA_RETURN_HOME, returnHome)
                 .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP))
             return true
         }
         return startSession(Intent(this, SessionActivity::class.java)
                 .putExtra(SessionActivity.EXTRA_RETURN_HOME, returnHome)
-                .putExtra(SessionService.EXTRA_STEAM_URL,
-                com.droiddeck.launcher.frontend.GameLaunchLink.steamUrl(game.gameIdString)), steamSession = true)
+                .apply {
+                    if (game.gameIdString == com.droiddeck.launcher.gpu.SteamVr.APP_ID) {
+                        putExtra(SessionActivity.EXTRA_STEAMVR, true)
+                    } else {
+                        putExtra(SessionService.EXTRA_STEAM_URL,
+                            com.droiddeck.launcher.frontend.GameLaunchLink.steamUrl(game.gameIdString))
+                    }
+                }, steamSession = true)
+    }
+
+    private fun launchWithoutSteam(game: Library.SteamGame, returnHome: Boolean): Boolean {
+        val app = applicationContext
+        Thread({
+            val added = if (game.library == Library.ADDED) runCatching { com.droiddeck.launcher.session.NoSteamLaunch.addedGame(app, game) }.getOrNull() else null
+            val command = com.droiddeck.launcher.session.NoSteamLaunch.command(game, added)
+            ui.post {
+                if (isDestroyed) return@post
+                if (command == null) {
+                    android.widget.Toast.makeText(this, R.string.game_link_failed, android.widget.Toast.LENGTH_LONG).show()
+                    return@post
+                }
+                com.droiddeck.launcher.session.NoSteamLaunch.remember(command)
+                val next = Intent(this, SessionActivity::class.java)
+                    .putExtra(SessionActivity.EXTRA_RETURN_HOME, returnHome)
+                    .putExtra(SessionService.EXTRA_MODE, SessionService.MODE_RUN)
+                    .putExtra(SessionService.EXTRA_PROGRAM, command.program)
+                    .putExtra(SessionService.EXTRA_PROGRAM_ARGS, command.args.toTypedArray())
+                when {
+                    !SessionState.running -> startSessionOrWait(next)
+                    SessionState.stopRequested -> android.widget.Toast.makeText(this, R.string.game_link_session_busy, android.widget.Toast.LENGTH_LONG).show()
+                    SessionState.mode == SessionService.MODE_RUN && SessionState.program == command.program && SessionState.programArgs == command.args ->
+                        startActivity(Intent(this, SessionActivity::class.java).setAction(SessionService.ACTION_RESUME)
+                            .putExtra(SessionActivity.EXTRA_RETURN_HOME, returnHome)
+                            .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP))
+                    else -> pendingSwitch = next
+                }
+            }
+        }, "no-steam-launch").start()
+        return true
+    }
+
+    private fun opensEpicLauncher(next: Intent): Boolean =
+        next.getStringExtra(SessionService.EXTRA_PROGRAM) == com.droiddeck.launcher.session.NoSteamLaunch.EPIC ||
+            next.getStringExtra(SessionService.EXTRA_STEAM_URL) == com.droiddeck.launcher.frontend.GameLaunchLink.steamUrl(
+                com.droiddeck.launcher.stores.epic.EpicClient.gameId(com.droiddeck.launcher.stores.epic.EpicClient.shortcutAppId))
+
+    private fun uninstallEpicLauncher() {
+        if (com.droiddeck.launcher.stores.epic.EpicClient.uninstalling) return
+        com.droiddeck.launcher.stores.epic.EpicClient.uninstalling = true
+        pendingSwitch?.takeIf(::opensEpicLauncher)?.let { pendingSwitch = null }
+        switchingTo?.takeIf(::opensEpicLauncher)?.let {
+            switchPoll?.let { poll -> ui.removeCallbacks(poll) }
+            switchPoll = null
+            switchingTo = null
+        }
+        if (SessionState.running) SessionService.stop(this)
+        val app = applicationContext
+        val deadline = android.os.SystemClock.uptimeMillis() + SESSION_SWITCH_WAIT_MS
+        Thread({
+            while ((SessionState.running || SessionState.phase !in SESSION_ENDED) && android.os.SystemClock.uptimeMillis() < deadline) {
+                Thread.sleep(SESSION_SWITCH_POLL_MS)
+            }
+            val ended = !SessionState.running && SessionState.phase in SESSION_ENDED
+            val done = try {
+                ended && com.droiddeck.launcher.stores.epic.EpicClient.uninstall(app)
+            } finally {
+                com.droiddeck.launcher.stores.epic.EpicClient.uninstalling = false
+            }
+            ui.post {
+                if (!isDestroyed) refresh()
+                android.widget.Toast.makeText(app, if (done) R.string.epic_client_uninstalled else R.string.epic_client_uninstall_failed,
+                    android.widget.Toast.LENGTH_LONG).show()
+            }
+        }, "epic-uninstall").start()
+    }
+
+    private fun openEpicLauncher(): Boolean {
+        if (com.droiddeck.launcher.stores.epic.EpicClient.uninstalling) {
+            android.widget.Toast.makeText(this, R.string.epic_client_uninstalling, android.widget.Toast.LENGTH_SHORT).show()
+            return false
+        }
+        if (protons.protonBusyId != null || ProtonExtras.installInProgress || pkgStage != null) {
+            android.widget.Toast.makeText(this, R.string.main_wait_install_game, android.widget.Toast.LENGTH_SHORT).show()
+            return false
+        }
+        if (!com.droiddeck.launcher.stores.epic.EpicClient.launcherRunning(this) && !com.droiddeck.launcher.stores.epic.EpicClient.fexReady(this)) {
+            com.droiddeck.launcher.stores.epic.EpicClient.requestFex(this)
+            android.widget.Toast.makeText(this, R.string.epic_client_needs_fex, android.widget.Toast.LENGTH_LONG).show()
+            if (!SessionState.running) startSteamSession()
+            else if (SessionState.mode == SessionService.MODE_STEAM) startActivity(Intent(this, SessionActivity::class.java)
+                .setAction(SessionService.ACTION_RESUME).addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP))
+            return true
+        }
+        if (com.droiddeck.launcher.session.NoSteamLaunch.enabled(this, com.droiddeck.launcher.stores.epic.EpicClient.shortcutAppId)) {
+            com.droiddeck.launcher.stores.epic.EpicClient.launcherEntry(this, Library.EPIC_LAUNCHER_NAME)?.let { return launchWithoutSteam(it, false) }
+        }
+        val launcher = Intent(this, SessionActivity::class.java)
+            .putExtra(SessionActivity.EXTRA_RETURN_HOME, false)
+            .putExtra(SessionService.EXTRA_STEAM_URL, com.droiddeck.launcher.frontend.GameLaunchLink.steamUrl(
+                com.droiddeck.launcher.stores.epic.EpicClient.gameId(com.droiddeck.launcher.stores.epic.EpicClient.shortcutAppId)))
+        if (SessionState.running && SessionState.mode == SessionService.MODE_STEAM && !SessionState.stopRequested) {
+            val app = applicationContext
+            val shortcut = com.droiddeck.launcher.stores.epic.EpicClient.shortcutAppId
+            val listed = com.droiddeck.launcher.frontend.AddedGames.inSteam(app, shortcut)
+            if (listed && !SessionService.launchGame(this, com.droiddeck.launcher.stores.epic.EpicClient.gameId(shortcut))) {
+                android.widget.Toast.makeText(this, R.string.game_link_failed, android.widget.Toast.LENGTH_LONG).show()
+                return false
+            }
+            startActivity(Intent(this, SessionActivity::class.java).setAction(SessionService.ACTION_RESUME)
+                .putExtra(SessionActivity.EXTRA_RETURN_HOME, false)
+                .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP))
+            if (!listed) Thread({
+                com.droiddeck.launcher.frontend.AddedGamesPublisher.republish(app)
+                val id = com.droiddeck.launcher.stores.epic.EpicClient.steamLauncherId(app) ?: shortcut
+                ui.post { SessionService.launchGame(app, com.droiddeck.launcher.stores.epic.EpicClient.gameId(id)) }
+            }, "epic-launcher-open").start()
+            return true
+        }
+        if (SessionState.running) {
+            if (SessionState.stopRequested) android.widget.Toast.makeText(this, R.string.game_link_session_busy, android.widget.Toast.LENGTH_LONG).show()
+            else pendingSwitch = launcher
+            return true
+        }
+        return startSessionOrWait(launcher)
+    }
+
+    private fun startSessionOrWait(next: Intent): Boolean {
+        val started = startSession(next, steamSession = next.hasExtra(SessionService.EXTRA_STEAM_URL))
+        if (!started && (busy || LinuxRuntimeInstaller.isBusy())) android.widget.Toast.makeText(this, R.string.main_wait_install_game, android.widget.Toast.LENGTH_SHORT).show()
+        return started
+    }
+
+    private fun startAfterSession(next: Intent) {
+        SessionService.stop(this)
+        awaitSessionEnd(next, android.os.SystemClock.uptimeMillis() + SESSION_SWITCH_WAIT_MS)
+    }
+
+    private fun awaitSessionEnd(next: Intent, deadline: Long) {
+        switchingTo = next
+        switchDeadline = deadline
+        switchPoll?.let { ui.removeCallbacks(it) }
+        val poll = object : Runnable {
+            override fun run() {
+                if (isDestroyed) return
+                if (SessionState.running || SessionState.phase !in SESSION_ENDED) {
+                    if (android.os.SystemClock.uptimeMillis() < deadline) ui.postDelayed(this, SESSION_SWITCH_POLL_MS)
+                    else {
+                        switchPoll = null
+                        switchingTo = null
+                        android.widget.Toast.makeText(this@MainActivity, R.string.game_link_session_busy, android.widget.Toast.LENGTH_LONG).show()
+                    }
+                    return
+                }
+                switchPoll = null
+                switchingTo = null
+                if (com.droiddeck.launcher.stores.epic.EpicClient.uninstalling && opensEpicLauncher(next)) return
+                startSessionOrWait(next)
+            }
+        }
+        switchPoll = poll
+        ui.postDelayed(poll, SESSION_SWITCH_POLL_MS)
     }
 
     private fun handleGameLink(games: List<Library.SteamGame>) {
@@ -509,11 +727,17 @@ class MainActivity : ComponentActivity() {
         theme = SessionPrefs.theme(this)
         frameGenLabel = getString(R.string.frame_gen_off)
         appScale = com.droiddeck.launcher.core.AppUiPrefs.scale(this)
-        steamGames = if (shortcutPicker) emptyList() else com.droiddeck.launcher.frontend.LibraryCache.load(this)
+        val (cached, cachedX64) = com.droiddeck.launcher.frontend.LibraryCache.snapshot(this)
+        steamGames = if (shortcutPicker) emptyList() else cached
+        steamGamesX64 = cachedX64
         backActionsInverted = SessionPrefs.backActionsInverted(this)
         orientation = SessionPrefs.orientation(this)
         requestedOrientation = orientation
         launcherFullscreen = SessionPrefs.launcherFullscreen(this)
+        downloadSource = DownloadSource.mode(this)
+        downloadMirror = DownloadSource.mirror(this)
+        downloadPrefix = DownloadSource.custom(this)
+        DownloadSource.probe()
         animationsEnabled = SessionPrefs.animationsEnabled(this)
         gameStoresEnabled = SessionPrefs.gameStoresEnabled(this)
         gameStoresSpeedTier = SessionPrefs.gameStoresSpeedTier(this)
@@ -542,8 +766,9 @@ class MainActivity : ComponentActivity() {
                         busy = busy, stage = stage, percent = percent,
                         desktopInstalled = desktopInstalled, desktopPresent = desktopPresent,
                         offlineAccount = offlineAccount, offline = offline,
-                        frameGenLabel = frameGenLabel, romsDir = romsDir, logsEnabled = logsEnabled, agentCommands = agentCommands,
-                        steamGames = steamGames, emulators = emulatorList, running = runningLabel,
+                        frameGenLabel = frameGenLabel, romsDir = romsDir, logsEnabled = logsEnabled,
+                        vacDiagnostics = vacDiagnostics, agentCommands = agentCommands,
+                        steamGames = steamGames, steamGamesX64 = steamGamesX64, emulators = emulatorList, running = runningLabel,
                         frameGen = FrameGen.mode(this),
                         lossless = lossless,
                         pageKey = if (showPerformance) "performance" else if (showComponents) "components" else if (showMapping) "controller-mapping" else null,
@@ -570,6 +795,9 @@ class MainActivity : ComponentActivity() {
                         showPhantomGate = showPhantomGate,
                         orientation = orientation,
                         launcherFullscreen = launcherFullscreen,
+                        downloadSource = downloadSource,
+                        downloadMirror = downloadMirror,
+                        downloadPrefix = downloadPrefix,
                         animationsEnabled = animationsEnabled,
                         gameStoresEnabled = gameStoresEnabled,
                         gameStoresSpeedTier = gameStoresSpeedTier,
@@ -583,7 +811,13 @@ class MainActivity : ComponentActivity() {
                         storeDownloadsActive = com.droiddeck.launcher.stores.StoresState.activeDownloads,
                     ),
                     FrontEndActions(
-                        onPlay = { startSteamSession() },
+                        onPlay = { playSteam() },
+                        onPlaySteamVr = { playSteamVr() },
+                        onSteamUrl = { url ->
+                            if (!SessionState.running) startSession(
+                                Intent(this, SessionActivity::class.java).putExtra(SessionService.EXTRA_STEAM_URL, url), steamSession = true,
+                            )
+                        },
                         onPlayDesktopUi = {
                             startSession(Intent(this, SessionActivity::class.java)
                                 .putExtra(SessionService.EXTRA_MODE, SessionService.MODE_STEAM)
@@ -596,6 +830,8 @@ class MainActivity : ComponentActivity() {
                                 com.droiddeck.launcher.stores.StoreLaunch.prepare(this, g) { launchGame(g) }
                             }
                         },
+                        onEpicLauncher = { openEpicLauncher() },
+                        onUninstallEpicLauncher = { uninstallEpicLauncher() },
                         onGameShortcut = { g -> com.droiddeck.launcher.frontend.GameShortcuts.pin(this, g) },
                         onExportGameFile = { g -> pickGameExport(g) },
                         onSyncGameFiles = { pickGameExport(null) },
@@ -604,6 +840,7 @@ class MainActivity : ComponentActivity() {
                             val known = steamGames.mapNotNull { it.gameFiles?.path }.toSet()
                             updateAddedGames(folders, then = { if (folders.any { it !in known }) fetchAddedGameArt() })
                         },
+                        onSteamGameArtChanged = { appId -> refreshSteamGameArt(appId) },
                         onAddedGameRemoved = { folder, appId, name -> removeAddedGame(folder, appId, name) },
                         onAddedGamesArt = { on -> SessionPrefs.setAddedGamesArt(this, on); addedGamesArt = on; if (on) refreshAddedGames() },
                         onSgdbKey = { key ->
@@ -680,6 +917,10 @@ class MainActivity : ComponentActivity() {
                             SessionPrefs.setLogsEnabled(this, !SessionPrefs.logsEnabled(this))
                             logsEnabled = SessionPrefs.logsEnabled(this)
                         },
+                        onVacDiagnostics = {
+                            SessionPrefs.setVacDiagnostics(this, !SessionPrefs.vacDiagnostics(this))
+                            vacDiagnostics = SessionPrefs.vacDiagnostics(this)
+                        },
                         onAgentCommands = {
                             com.droiddeck.launcher.agent.AgentAccess.setCommandsEnabled(this, !com.droiddeck.launcher.agent.AgentAccess.commandsEnabled(this))
                             agentCommands = com.droiddeck.launcher.agent.AgentAccess.commandsEnabled(this)
@@ -743,6 +984,18 @@ class MainActivity : ComponentActivity() {
                             animationsEnabled = on
                             com.droiddeck.launcher.ui.Motion.refresh(this)
                         },
+                        onDownloadSource = { mode ->
+                            DownloadSource.setMode(this, mode)
+                            downloadSource = mode
+                        },
+                        onDownloadMirror = { host ->
+                            DownloadSource.setMirror(this, host)
+                            downloadMirror = host
+                        },
+                        onDownloadPrefix = { prefix ->
+                            DownloadSource.setCustom(this, prefix)
+                            downloadPrefix = DownloadSource.custom(this)
+                        },
                         onHomeApp = { manageHomeApp() },
                         onHomeScreen = { on ->
                             HomeApp.setHomeScreenEnabled(this, on)
@@ -816,6 +1069,7 @@ class MainActivity : ComponentActivity() {
                             onQamButton = { on -> ControllerPrefs.setQamButton(this, on); refreshController() },
                             onKeyboardButton = { on -> ControllerPrefs.setKeyboardButton(this, on); refreshController() },
                             onSelectSteam = { on -> ControllerPrefs.setSelectSteam(this, on); refreshController() },
+                            onJoyConVr = { on -> ControllerPrefs.setJoyConVr(this, on); refreshController() },
                             onEditLayout = { startActivity(Intent(this, ControllerEditorActivity::class.java)) },
                             onResetLayout = { ControllerPrefs.resetAllLayouts(this); refreshController() },
                             onMapping = { showPerformance = false; showComponents = false; showMapping = true },
@@ -843,6 +1097,15 @@ class MainActivity : ComponentActivity() {
                         onDismiss = { showNonAdreno = null },
                     )
                 }
+                pendingSwitch?.let { next ->
+                    ConfirmDialog(
+                        title = androidx.compose.ui.res.stringResource(R.string.drawer_stop_title),
+                        text = runningLabel ?: "",
+                        confirm = androidx.compose.ui.res.stringResource(R.string.drawer_stop),
+                        onConfirm = { pendingSwitch = null; startAfterSession(next) },
+                        onDismiss = { pendingSwitch = null },
+                    )
+                }
                 if (showRemove) ConfirmDialog(
                     title = androidx.compose.ui.res.stringResource(R.string.main_remove_runtime_title),
                     text = androidx.compose.ui.res.stringResource(R.string.main_remove_runtime_text),
@@ -850,6 +1113,20 @@ class MainActivity : ComponentActivity() {
                     onConfirm = { showRemove = false; removeRuntime() },
                     onDismiss = { showRemove = false },
                 )
+                lowSpace?.let { free ->
+                    com.droiddeck.launcher.ui.LowSpaceDialog(
+                        free,
+                        onFreeUp = { lowSpace = null; com.droiddeck.launcher.storage.StorageState.requestOpen() },
+                        onPlay = { lowSpace = null; com.droiddeck.launcher.storage.StorageState.lowSpaceDismissed = true; startSteamSession() },
+                        onDismiss = { lowSpace = null },
+                    )
+                }
+                com.droiddeck.launcher.ui.HandCameraHost(
+                    check = placementCheck,
+                    onAskPermission = { cameraPermission.launch(Manifest.permission.CAMERA) },
+                    onPlay = { placementCheck = null; startSteamSession(steamVr = true) },
+                    onClose = { placementCheck = null },
+                )
                 if (showResetSettings) com.droiddeck.launcher.ui.ResetSettingsDialog(
                     onConfirm = { gameProfiles -> resetSettings(gameProfiles) },
                     onDismiss = { showResetSettings = false },
@@ -867,6 +1144,10 @@ class MainActivity : ComponentActivity() {
         }
 
         if (savedInstanceState == null) ui.post { startSteamAtStartupIfEnabled() }
+        else {
+            pendingSwitch = savedIntent(savedInstanceState, KEY_PENDING_SWITCH)
+            savedIntent(savedInstanceState, KEY_SWITCHING_TO)?.let { awaitSessionEnd(it, savedInstanceState.getLong(KEY_SWITCH_DEADLINE)) }
+        }
 
         val wanted = ArrayList<String>()
         if (checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
@@ -902,8 +1183,23 @@ class MainActivity : ComponentActivity() {
         if (SessionPrefs.runSteamAtStartup(this) && !isFinishing && !isDestroyed) startSteamSession()
     }
 
-    private fun startSteamSession() {
-        startSession(Intent(this, SessionActivity::class.java), steamSession = true)
+    private fun playSteam() {
+        val storage = com.droiddeck.launcher.storage.StorageState
+        if (!SessionState.running && !storage.lowSpaceDismissed && storage.lowOnSpace(this)) {
+            lowSpace = storage.freeBytes(this)
+            storage.refresh(this)
+        } else startSteamSession()
+    }
+
+    private fun playSteamVr() {
+        val tracking = com.droiddeck.launcher.glasses.Glasses.settings.value
+        if (!com.droiddeck.launcher.glasses.Glasses.state.value.usesSpatialControllers(tracking) &&
+            com.droiddeck.launcher.handtracking.HandTracking.wanted(this)) placementCheck = true
+        else startSteamSession(steamVr = true)
+    }
+
+    private fun startSteamSession(steamVr: Boolean = false) {
+        startSession(Intent(this, SessionActivity::class.java).putExtra(SessionActivity.EXTRA_STEAMVR, steamVr), steamSession = true)
     }
 
     override fun onWindowFocusChanged(hasFocus: Boolean) {
@@ -965,7 +1261,7 @@ class MainActivity : ComponentActivity() {
         refreshPhantomStatus()
         syncLossless()
         updates.onResume()
-        drivers.ensureAuto(force = false)
+        drivers.checkOnOpen()
         protons.checkUpdates()
         if (!SessionState.running) Thread({
             val applied = runCatching { ComponentsManager.applyQueued(this) }.getOrDefault(emptyList())
@@ -1000,6 +1296,19 @@ class MainActivity : ComponentActivity() {
         refreshSecondScreenDisplays()
     }
 
+    override fun onSaveInstanceState(outState: Bundle) {
+        super.onSaveInstanceState(outState)
+        pendingSwitch?.let { outState.putParcelable(KEY_PENDING_SWITCH, it) }
+        switchingTo?.let {
+            outState.putParcelable(KEY_SWITCHING_TO, it)
+            outState.putLong(KEY_SWITCH_DEADLINE, switchDeadline)
+        }
+    }
+
+    private fun savedIntent(state: Bundle, key: String): Intent? =
+        if (Build.VERSION.SDK_INT >= 33) state.getParcelable(key, Intent::class.java)
+        else @Suppress("DEPRECATION") state.getParcelable(key)
+
     override fun onDestroy() {
         updates.unregister()
         super.onDestroy()
@@ -1027,7 +1336,9 @@ class MainActivity : ComponentActivity() {
 
     private fun refreshSecondScreenDisplays() {
         if (!::displayManager.isInitialized) return
-        secondScreenDisplays = SecondScreenDisplays.available(displayManager)
+        // The launcher can itself be shown on a non-default display (DeX, an external monitor); that one is not a "second screen".
+        val ownDisplayId = if (android.os.Build.VERSION.SDK_INT >= 30) display?.displayId ?: android.view.Display.DEFAULT_DISPLAY else @Suppress("DEPRECATION") windowManager.defaultDisplay.displayId
+        secondScreenDisplays = SecondScreenDisplays.available(displayManager, ownDisplayId)
     }
 
     private fun launchAndroidApp(app: HomeApp.LaunchableApp, displayId: Int?) {
@@ -1161,6 +1472,8 @@ class MainActivity : ComponentActivity() {
                 onImportAndroid = { pickAndroidDriver.launch(InAppFilePicker.buildIntent(this, ZIP_EXT, getString(R.string.drivers_pick_android))) },
                 onImportZip = { pickAnyDriver.launch(InAppFilePicker.buildIntent(this, ZIP_EXT, getString(R.string.drivers_pick_any))) },
                 onRestoreBundled = { TurnipDriver(this).restoreBundled(); drivers.refreshDrivers() },
+                onMode = { m -> drivers.chooseMode(m) },
+                onRestart = { drivers.restartApp() },
             ),
             protons = com.droiddeck.launcher.ui.ProtonsState(
                 rows = protons.protonRows, busyId = protons.protonBusyId, stage = protons.protonStage, percent = protons.protonPercent,
@@ -1264,10 +1577,16 @@ class MainActivity : ComponentActivity() {
                 fexPreset = if (mode == SessionService.MODE_STEAM) fexPreset else null,
                 forceSsbs = forceSsbs,
                 syncBackend = if (mode == SessionService.MODE_STEAM) SessionPrefs.syncBackendOf(fastSync, fsyncFirst, syncFallback) else null,
+                steamClientArch = if (mode == SessionService.MODE_STEAM) steamClientArch else null,
                 steamRepairQueued = steamRepairQueued,
                 mangoapp = mangoapp,
                 steamController = if (mode == SessionService.MODE_STEAM) steamController else null,
                 runSteamAtStartup = mode == SessionService.MODE_STEAM && runSteamAtStartup,
+                bootMovie = if (mode == SessionService.MODE_STEAM) bootMovie else null,
+                bootMovieSound = bootMovieSound,
+                bootMovieCustomName = bootMovieCustomName,
+                bootMovieImporting = bootMovieImporting,
+                bootMovieProgress = bootMovieProgress,
                 wifiDiscovery = if (mode == SessionService.MODE_STEAM) wifiDiscovery else null,
                 wifiDiscoveryPermission = wifiDiscoveryPermission,
                 wifiDiscoveryLocation = wifiDiscoveryLocation,
@@ -1342,12 +1661,19 @@ class MainActivity : ComponentActivity() {
                     syncFallback = SessionPrefs.syncFallback(this)
                 },
                 onSteamRepair = { steamRepairQueued = SteamRepair.queue(this) },
+                onSteamClientArch = { id -> SessionPrefs.setSteamClientArch(this, id); steamClientArch = id; refresh() },
                 onMangoapp = { on -> SessionPrefs.setMangoapp(this, on); mangoapp = on },
                 onSteamController = { id -> SessionPrefs.setSteamController(this, id); steamController = id },
                 onRunSteamAtStartup = { on ->
                     SessionPrefs.setRunSteamAtStartup(this, on)
                     runSteamAtStartup = on
                 },
+                onBootMovie = { id -> SessionPrefs.setBootMovie(this, id); loadBootMovie() },
+                onBootMovieSound = { on -> SessionPrefs.setBootMovieSound(this, on); bootMovieSound = on },
+                onImportBootMovie = {
+                    pickBootMovie.launch(InAppFilePicker.buildIntent(this, com.droiddeck.launcher.session.BootMovie.PICKER_EXTENSIONS, getString(R.string.boot_movie_pick)))
+                },
+                onRemoveBootMovie = { com.droiddeck.launcher.session.BootMovie.removeCustom(this); loadBootMovie() },
                 onDeckyInstall = { release -> decky.installDecky(release) },
                 onDeckyCheck = { decky.refreshDecky() },
                 onDeckyEnabled = { enabled -> DeckyManager.setSupervisorEnabled(this, enabled); decky.deckySupervisor = enabled },
@@ -1418,6 +1744,20 @@ class MainActivity : ComponentActivity() {
         }, "added-games-update").start()
     }
 
+    private val steamArtRefreshes = HashMap<Int, Int>()
+
+    private fun refreshSteamGameArt(appId: Int) {
+        val version = (steamArtRefreshes[appId] ?: 0) + 1
+        steamArtRefreshes[appId] = version
+        Thread({
+            val fresh = com.droiddeck.launcher.frontend.Library.steamGames(this).firstOrNull { it.appId == appId } ?: return@Thread
+            ui.post {
+                if (steamArtRefreshes[appId] != version) return@post
+                steamGames = steamGames.map { if (it.appId == appId && it.library != Library.ADDED) fresh else it }
+            }
+        }, "steam-art-update").start()
+    }
+
     private fun removeAddedGame(folder: String, appId: Long?, name: String) {
         steamGames = steamGames.filterNot { it.library == Library.ADDED && it.gameFiles?.path == folder }
         Thread({ com.droiddeck.launcher.frontend.AddedGames.remove(this, java.io.File(folder), appId, name) }, "added-game-remove").start()
@@ -1461,10 +1801,12 @@ class MainActivity : ComponentActivity() {
         fastSync = SessionPrefs.fastSync(this)
         fsyncFirst = SessionPrefs.fsyncFirst(this)
         syncFallback = SessionPrefs.syncFallback(this)
+        steamClientArch = SessionPrefs.steamClientArch(this)
         steamRepairQueued = SteamRepair.queued(this)
         mangoapp = SessionPrefs.mangoapp(this)
         steamController = SessionPrefs.steamController(this)
         runSteamAtStartup = SessionPrefs.runSteamAtStartup(this)
+        loadBootMovie()
         hdrOn = SessionPrefs.hdr(this, mode)
         fpsLimit = SessionPrefs.fpsLimit(this, mode)
         upscaler = SessionPrefs.upscaler(this)
@@ -1536,7 +1878,14 @@ class MainActivity : ComponentActivity() {
     }
 
     private fun refresh() {
+        // Until the scan finishes, the other client's games would launch in this one.
+        val listX64 = SessionPrefs.activeSteamClientArch(this) == "x86_64"
+        if (listX64 != steamGamesX64) {
+            steamGamesX64 = listX64
+            steamGames = steamGames.filterNot(Library::fromSteamClient)
+        }
         if (!busy && LinuxRuntimeInstaller.isBusy()) followRuntimeOperation { LinuxRuntimeInstaller.attach(it) }
+        if (showComponents) drivers.refreshDrivers()
         addedGamesArt = SessionPrefs.addedGamesArt(this)
         desktopInstalled = DesktopCatalog.desktopInstalled(this)
         desktopPresent = DesktopCatalog.desktopPresent(this)
@@ -1548,6 +1897,7 @@ class MainActivity : ComponentActivity() {
         frameGenLabel = FrameGen.label(this)
         romsDir = SessionPrefs.romsDir(this).takeIf { it.isNotEmpty() }
         logsEnabled = SessionPrefs.logsEnabled(this)
+        vacDiagnostics = SessionPrefs.vacDiagnostics(this)
         agentCommands = com.droiddeck.launcher.agent.AgentAccess.commandsEnabled(this)
         runningLabel = if (SessionState.running) when (SessionState.mode) {
             SessionService.MODE_DESKTOP -> getString(R.string.rail_desktop)
@@ -1556,7 +1906,11 @@ class MainActivity : ComponentActivity() {
             else -> "Steam"
         } else null
         val scanGeneration = ++libraryScanGeneration
+        val artRefreshesAtStart = HashMap(steamArtRefreshes)
         if (shortcutPicker) shortcutLibraryScanning = true
+        if (SessionPrefs.steamClientArch(this) == "x86_64" && !OfflineMode.enabled(this)) {
+            Thread({ com.droiddeck.launcher.session.FexCatalog.refresh(this) }, "fex-catalog").start()
+        }
         Thread({
             val emus = Library.emulators(this) { id -> DesktopCatalog.installed(this, id) != null }
             ui.post { if (scanGeneration == libraryScanGeneration) emulatorList = emus }
@@ -1573,9 +1927,11 @@ class MainActivity : ComponentActivity() {
                     }
                 }
             }
-            val games = if (ready) Library.launchableGames(this) else emptyList()
+            val scannedArch = SessionPrefs.activeSteamClientArch(this)
+            val scannedX64 = scannedArch == "x86_64"
+            val games = if (ready) Library.launchableGames(this, arch = scannedArch) else emptyList()
             val all = games.distinctBy { it.gameId }
-            if (ready) com.droiddeck.launcher.frontend.LibraryCache.save(this, all)
+            if (ready && scanGeneration == libraryScanGeneration) com.droiddeck.launcher.frontend.LibraryCache.save(this, all, scannedX64)
             val endedSession = SessionState.sessionId.takeIf { !SessionState.running && it != null && it != componentSweepSession }
             if (ready && (!componentSweepDone || endedSession != null)) {
                 componentSweepDone = true
@@ -1584,7 +1940,12 @@ class MainActivity : ComponentActivity() {
             }
             ui.post {
                 if (scanGeneration == libraryScanGeneration) {
-                    steamGames = all
+                    val current = steamGames.filter { it.library != Library.ADDED }.associateBy { it.appId }
+                    steamGamesX64 = scannedX64
+                    steamGames = all.map { g ->
+                        val newer = current[g.appId]
+                        if (newer != null && g.library != Library.ADDED && steamArtRefreshes[g.appId] != artRefreshesAtStart[g.appId]) g.withArt(newer.art, newer.hero, newer.icon) else g
+                    }
                     shortcutLibraryScanning = false
                     handleGameLink(all)
                 }
@@ -1613,6 +1974,10 @@ class MainActivity : ComponentActivity() {
 
     private fun startSession(intent: Intent, steamSession: Boolean = false): Boolean {
         if (busy || LinuxRuntimeInstaller.isBusy()) return false
+        if (com.droiddeck.launcher.storage.StorageState.cleaning) {
+            android.widget.Toast.makeText(this, R.string.storage_cleanup_busy, android.widget.Toast.LENGTH_SHORT).show()
+            return false
+        }
         refreshPhantomStatus()
         if (steamSession && PhantomProcessLimit.blocksSteam(phantomProcessStatus)) {
             showPhantomGate = true
@@ -1726,6 +2091,12 @@ class MainActivity : ComponentActivity() {
     companion object {
         private const val TAG = "MainActivity"
         private const val MEDIA_SETTLE_MS = 1500L
+        private const val SESSION_SWITCH_WAIT_MS = 30_000L
+        private const val SESSION_SWITCH_POLL_MS = 250L
+        private const val KEY_PENDING_SWITCH = "pending_switch"
+        private const val KEY_SWITCHING_TO = "switching_to"
+        private const val KEY_SWITCH_DEADLINE = "switch_deadline"
+        private val SESSION_ENDED = setOf(SessionPhase.IDLE, SessionPhase.FAILED)
         private val ZIP_EXT = listOf("zip")
         private val WCP_EXT = listOf("wcp")
     }

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

@@ -26,7 +26,7 @@ class QuestXrActivity : NativeActivity() {
         if (active) {
             check(CompositorHost.isStarted) { "DroidDeck compositor is not running" }
             SessionService.resume(this)
-            WaylandCompositor.nativeSetCardboard(false, 1, 0.064f, 3f, 4f, 0f, 0f, 90f, 0f, 0f)
+            WaylandCompositor.nativeSetCardboard(false, 1, 0.064f, 3f, 4f, 0f, 0f, 90f, 0f, 0f, false, 0f)
             WaylandCompositor.nativeSetFrameGenArmed(false, 0, 0)
             WaylandCompositor.nativeSetZeroCopy(false)
             CompositorHost.attachXr()

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

@@ -92,11 +92,111 @@ class AgentBridgeProvider : ContentProvider() {
             AgentEnv.override(context, request.optString("name")).put("ok", true).put("command", "override")
         }
         "prefs" -> prefs(context, request)
+        "glasses" -> glasses(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 glasses(context: Context, request: JSONObject): JSONObject {
+        val g = com.droiddeck.launcher.glasses.Glasses
+        when (request.optString("op", "status")) {
+            "status" -> {}
+            "allow" -> g.requestControl()
+            "set" -> {
+                val key = request.optString("key")
+                val value = request.optString("value")
+                fun on() = value == "1" || value.equals("true", true) || value.equals("on", true)
+                val number = value.toIntOrNull()
+                val numeric = setOf("refreshHz", "sbsHz", "brightness", "volume", "picture3d", "screenWidthDm", "screenDistanceDm", "vrFovDeg", "sbsSupport", "eyeHeightCm")
+                if (key in numeric && number == null) return error("INVALID_VALUE", "'$key' takes a number")
+                when (key) {
+                    "refreshHz" -> g.setRefreshHz(number!!)
+                    "sbsHz" -> g.setSbsHz(number!!)
+                    "resolution2d" -> g.setResolution(com.droiddeck.launcher.glasses.GlassesDisplayProfile.TWO_D, value)
+                    "resolution3d" -> g.setResolution(com.droiddeck.launcher.glasses.GlassesDisplayProfile.THREE_D, value)
+                    "resolutionVr" -> g.setResolution(com.droiddeck.launcher.glasses.GlassesDisplayProfile.VR, value)
+                    "brightness" -> g.setBrightness(number!!)
+                    "volume" -> g.setVolume(number!!)
+                    "sunblock" -> g.setSunblock(on())
+                    "3d" -> g.set3d(on())
+                    "3dof" -> g.set3dof(on())
+                    "gameOnGlasses" -> g.setGameOnGlasses(on())
+                    "headTracking" -> g.setHeadTracking(on())
+                    "auto3d" -> g.setAuto3d(on())
+                    "picture3d" -> g.setPicture3d(number!!)
+                    "screenWidthDm" -> g.setScreenWidthDm(number!!)
+                    "screenDistanceDm" -> g.setScreenDistanceDm(number!!)
+                    "vrFovDeg" -> g.setVrFovDeg(number!!)
+                    "sbsSupport" -> g.setSbsSupport(number!!)
+                    "positionalTracking" -> g.setPositionalTracking(on())
+                    "handControllers" -> g.setHandControllers(on())
+                    "joyConTracking" -> g.setJoyConTracking(on())
+                    "eyeHeightCm" -> g.setEyeHeight(number!!)
+                    else -> return error("INVALID_KEY", "Unknown glasses setting '$key'")
+                }
+            }
+            "simulate" -> {
+                fun angle(key: String) = if (request.has(key)) request.optDouble(key).takeIf { it.isFinite() }?.coerceIn(-90.0, 90.0) else null
+                if (!g.simulate(request.optInt("seconds", 20).coerceIn(1, 600), angle("yaw"), angle("pitch"))) return error("BUSY", "Already simulating")
+            }
+            "stop-simulate" -> g.stopSimulation()
+            "calibrate" -> g.startCalibration()
+            "cancel-calibration" -> g.cancelCalibration()
+            "reset-calibration" -> g.resetCalibration()
+            "spatial-diagnostics" -> com.droiddeck.launcher.glasses.SpatialTracking.diagnostics(request.optBoolean("enabled",true))
+            "spatial-recenter" -> com.droiddeck.launcher.glasses.SpatialTracking.recenter(request.optBoolean("screen",false))
+            "spatial-floor" -> g.setSpatialFloor()
+            "spatial-restart" -> g.restartSpatialTracking()
+            "spatial-hand-options" -> {
+                AgentAccess.requireCommands(context)
+                if(request.has("lite")) com.droiddeck.launcher.glasses.SpatialTracking.setHandModel(request.getBoolean("lite"))
+                if(request.has("parallel")) com.droiddeck.launcher.glasses.SpatialTracking.setHandCpuParallel(request.getBoolean("parallel"))
+                if(request.has("halfRate")) com.droiddeck.launcher.glasses.SpatialTracking.setHandHalfRate(request.getBoolean("halfRate"))
+                if(request.has("adaptive")) com.droiddeck.launcher.glasses.SpatialTracking.setHandAdaptiveInput(request.getBoolean("adaptive"))
+                if(request.has("scheduled")) com.droiddeck.launcher.glasses.SpatialTracking.setHandScheduledTracking(request.getBoolean("scheduled"))
+            }
+            "spatial-hand-benchmark" -> {
+                AgentAccess.requireCommands(context)
+                com.droiddeck.launcher.glasses.SpatialTracking.benchmarkSavedCapture(request.getString("capture"))
+            }
+            "spatial-hand-capture" -> {
+                AgentAccess.requireCommands(context)
+                com.droiddeck.launcher.glasses.SpatialTracking.captureDiagnostic()
+            }
+            "spatial-rgb-capture", "spatial-rgb-status" -> {
+                AgentAccess.requireCommands(context)
+                return (if (request.getString("op") == "spatial-rgb-capture")
+                    com.droiddeck.launcher.glasses.LumaRgbDiagnostic.capture(context!!,request.optString("transport","sdk"),
+                        request.optInt("width",640),request.optInt("height",480),request.optInt("fps",30),
+                        request.optInt("durationMs",5000))
+                else com.droiddeck.launcher.glasses.LumaRgbDiagnostic.status(context!!)).put("ok", true)
+            }
+            "query" -> { g.query(); Thread.sleep(600) }
+            "mode" -> {
+                val mode = hex(request.optString("mode"), 0xFF) ?: return error("INVALID_VALUE", "mode must be one hex byte, e.g. 0x31")
+                g.sendMode(mode)
+                Thread.sleep(600)
+            }
+            "imu" -> return g.sampleImu(request.optLong("ms", 2000).coerceIn(200, 20_000)).put("ok", true).put("command", "glasses")
+            "raw" -> {
+                AgentAccess.requireCommands(context)
+                val msgId = hex(request.optString("msgId"), 0xFFFF) ?: return error("INVALID_VALUE", "msgId must be a hex number up to 0xFFFF")
+                val digits = request.optString("payload").removePrefix("0x")
+                if (digits.length % 2 != 0 || digits.any { Character.digit(it, 16) < 0 }) return error("INVALID_VALUE", "payload must be whole hex bytes")
+                val payload = digits.chunked(2).map { it.toInt(16).toByte() }.toByteArray()
+                if (!g.sendRaw(msgId, payload)) return error("NOT_CONNECTED", "The glasses' control link is not open")
+                Thread.sleep(300)
+            }
+            else -> return error("INVALID_OP", "Unknown glasses op")
+        }
+        if (request.optString("op") in setOf("set", "allow")) Thread.sleep(400)
+        return g.status().put("ok", true).put("command", "glasses").put("frames", g.recentFrames())
+    }
+
+    private fun hex(text: String, max: Int): Int? =
+        text.removePrefix("0x").removePrefix("0X").takeIf { it.isNotEmpty() }?.toIntOrNull(16)?.takeIf { it in 0..max }
+
     private fun state(context: Context): JSONObject {
         val runtimeVersion = LinuxRuntimeInstaller.installedVersion(context)
         val dir = SessionState.logDirectory ?: SessionState.logFile?.parentFile ?: SessionPaths.sessionFolders(context).lastOrNull()
@@ -109,6 +209,7 @@ class AgentBridgeProvider : ContentProvider() {
             .put("steamUi", SessionState.steamUi ?: JSONObject.NULL)
             .put("steamUrl", SessionState.steamUrl ?: JSONObject.NULL)
             .put("suspended", SessionState.suspended)
+            .put("steamVr", SessionState.steamVr)
             .put("pip", SessionState.pipActive)
             .put("firstFrame", SessionState.firstFrameSeen)
             .put("output", JSONArray().put(SessionState.outputSize.first).put(SessionState.outputSize.second))

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

@@ -136,8 +136,12 @@ object AgentGuest {
         return null
     }
 
-    fun call(context: Context, request: JSONObject, timeoutMs: Long): JSONObject {
-        if (request.optString("kind") in setOf("exec", "cdp")) AgentAccess.requireCommands(context)
+    fun steamEval(context: Context, expression: String, timeoutMs: Long): JSONObject =
+        call(context, JSONObject().put("kind", "cdp").put("expression", expression).put("timeout", timeoutMs / 1000.0),
+            timeoutMs + 2_000, trusted = true)
+
+    fun call(context: Context, request: JSONObject, timeoutMs: Long, trusted: Boolean = false): JSONObject {
+        if (!trusted && 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)

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

@@ -97,6 +97,7 @@ class AgentStartActivity : Activity() {
                 request.optString("steamUrl").takeIf { it.startsWith("steam://") }?.let {
                     putExtra(SessionService.EXTRA_STEAM_URL, it)
                 }
+                if (request.optBoolean("steamVr")) putExtra(SessionActivity.EXTRA_STEAMVR, true)
             }
         }
         startActivity(sessionIntent)

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

@@ -2,10 +2,15 @@ package com.droiddeck.launcher.core
 
 import android.app.ActivityManager
 import android.content.Context
+import android.hardware.display.DisplayManager
 import android.os.Build
 import android.os.Environment
+import android.os.PerformanceHintManager
+import android.os.PowerManager
 import android.os.StatFs
+import android.provider.Settings
 import android.util.Log
+import android.view.Display
 import com.droiddeck.launcher.gpu.LinuxVulkanDriver
 import com.droiddeck.launcher.gpu.LinuxVulkanDriverManager
 import com.droiddeck.launcher.gpu.TurnipDriver
@@ -32,6 +37,57 @@ object DeviceReport {
         }
     }
 
+    /** Name of an ApplicationExitInfo reason code, so a report says "LOW_MEMORY" instead of "3". */
+    internal fun exitReasonName(reason: Int): String = when (reason) {
+        0 -> "UNKNOWN"
+        1 -> "EXIT_SELF"
+        2 -> "SIGNALED"
+        3 -> "LOW_MEMORY"
+        4 -> "CRASH"
+        5 -> "CRASH_NATIVE"
+        6 -> "ANR"
+        7 -> "INITIALIZATION_FAILURE"
+        8 -> "PERMISSION_CHANGE"
+        9 -> "EXCESSIVE_RESOURCE_USAGE"
+        10 -> "USER_REQUESTED"
+        11 -> "USER_STOPPED"
+        12 -> "DEPENDENCY_DIED"
+        13 -> "OTHER"
+        14 -> "FREEZER"
+        15 -> "PACKAGE_STATE_CHANGE"
+        16 -> "PACKAGE_UPDATED"
+        else -> "REASON_$reason"
+    }
+
+    internal fun thermalStatusName(status: Int): String = when (status) {
+        0 -> "NONE"
+        1 -> "LIGHT"
+        2 -> "MODERATE"
+        3 -> "SEVERE"
+        4 -> "CRITICAL"
+        5 -> "EMERGENCY"
+        6 -> "SHUTDOWN"
+        else -> "STATUS_$status"
+    }
+
+    internal fun gameModeName(mode: Int): String = when (mode) {
+        0 -> "UNSUPPORTED"
+        1 -> "STANDARD"
+        2 -> "PERFORMANCE"
+        3 -> "BATTERY"
+        4 -> "CUSTOM"
+        else -> "MODE_$mode"
+    }
+
+    internal fun refreshModesSummary(rates: List<Float>): String =
+        rates.map { Math.round(it) }.distinct().sortedDescending().joinToString(", ") { "$it Hz" }
+
+    internal fun exitSummary(processName: String?, reason: Int, status: Int, description: String?): String =
+        buildString {
+            append(processName ?: "?").append("  ").append(exitReasonName(reason)).append("  status=").append(status)
+            if (!description.isNullOrBlank()) append("  ").append(description.trim())
+        }
+
     fun build(context: Context, mode: String): String {
         val b = StringBuilder()
         fun h(title: String) {
@@ -68,6 +124,20 @@ object DeviceReport {
         k("Fingerprint", Build.FINGERPRINT)
         k("Kernel", System.getProperty("os.version"))
         k("ABIs", Build.SUPPORTED_ABIS.joinToString(", "))
+        k("Memory page size", runCatching { android.system.Os.sysconf(android.system.OsConstants._SC_PAGESIZE) }.getOrNull()?.let { "$it bytes" })
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            h("Recent process exits")
+            val exits = runCatching {
+                context.getSystemService(android.app.ActivityManager::class.java).getHistoricalProcessExitReasons(context.packageName, 0, 5)
+            }.getOrNull().orEmpty()
+            if (exits.isEmpty()) k("Exits", "none recorded") else {
+                val stamp = SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US)
+                for (e in exits) {
+                    k(stamp.format(Date(e.timestamp)), exitSummary(e.processName, e.reason, e.status, e.description))
+                }
+            }
+        }
 
         h("CPU and memory")
         k("Cores", CpuCores.all.size)
@@ -82,6 +152,19 @@ object DeviceReport {
             k("RAM total", FileUtils.sizeToString(mi.totalMem))
             k("RAM available", FileUtils.sizeToString(mi.availMem))
         }
+        runCatching {
+            val pm = context.getSystemService(Context.POWER_SERVICE) as PowerManager
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) k("Thermal status", thermalStatusName(pm.currentThermalStatus))
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                k("Thermal headroom (10 s)", pm.getThermalHeadroom(10).let { if (it.isNaN()) "not reported" else String.format(Locale.US, "%.2f", it) })
+            }
+            k("Power saver", pm.isPowerSaveMode)
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            val rate = runCatching { context.getSystemService(PerformanceHintManager::class.java)?.preferredUpdateRateNanos }.getOrNull()
+            k("ADPF hint sessions", if (rate == null || rate <= 0) "not supported" else "supported (preferred update ${rate / 1000} us)")
+            k("Game Mode", runCatching { context.getSystemService(android.app.GameManager::class.java)?.gameMode }.getOrNull()?.let { gameModeName(it) })
+        }
         runCatching {
             val fs = StatFs(context.filesDir.path)
             k("App storage free", FileUtils.sizeToString(fs.availableBlocksLong * fs.blockSizeLong))
@@ -99,6 +182,13 @@ 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))
+        runCatching {
+            val display = context.getSystemService(DisplayManager::class.java).getDisplay(Display.DEFAULT_DISPLAY)
+            k("Panel refresh now", String.format(Locale.US, "%.2f Hz", display.refreshRate))
+            k("Panel refresh modes", refreshModesSummary(display.supportedModes.map { it.refreshRate }))
+        }
+        k("peak_refresh_rate", runCatching { Settings.System.getString(context.contentResolver, "peak_refresh_rate") }.getOrNull() ?: "not set")
+        k("refresh_rate_mode", runCatching { Settings.Secure.getString(context.contentResolver, "refresh_rate_mode") }.getOrNull() ?: "not set")
         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)

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

@@ -0,0 +1,207 @@
+package com.droiddeck.launcher.core
+
+import android.content.Context
+import android.content.SharedPreferences
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicLong
+
+object DownloadSource {
+    const val MODE_AUTO = "auto"
+    const val MODE_DIRECT = "direct"
+    const val MODE_MIRROR = "mirror"
+    const val MODE_CUSTOM = "custom"
+
+    private const val PREFS = "download-source"
+    private const val KEY_MODE = "mode"
+    private const val KEY_MIRROR = "mirror"
+    private const val KEY_CUSTOM = "custom"
+    private const val KEY_FASTEST = "fastest"
+
+    private const val PROBE = "https://raw.githubusercontent.com/Droid-Deck/DroidDeck/main/README.md"
+    private const val PROBE_TIMEOUT_MS = 4_000
+    private const val PROBE_COOLDOWN_MS = 30_000L
+    private const val UA = "DroidDeck-Android"
+
+    private val MODES = listOf(MODE_AUTO, MODE_DIRECT, MODE_MIRROR, MODE_CUSTOM)
+
+    private val GITHUB_HOSTS = listOf(
+        "github.com",
+        "raw.githubusercontent.com",
+        "api.github.com",
+    )
+
+    private val CATALOGS = listOf(
+        "https://raw.githubusercontent.com/Droid-Deck/DroidDeck-CI/",
+        "https://raw.githubusercontent.com/Droid-Deck/DroidDeck-Components/",
+    )
+
+    data class Mirror(val host: String, val api: Boolean)
+
+    val MIRRORS = listOf(
+        Mirror("gh-proxy.com", true),
+        Mirror("gh-proxy.org", true),
+        Mirror("ghproxy.net", false),
+        Mirror("ghfast.top", false),
+    )
+
+    @Volatile
+    private var app: Context? = null
+
+    @Volatile
+    private var lastGood: String? = null
+
+    private val probing = AtomicBoolean(false)
+    private val probedAt = AtomicLong(0L)
+
+    fun init(context: Context) {
+        app = context.applicationContext
+        lastGood = prefs()?.getString(KEY_FASTEST, null)
+    }
+
+    fun probe() {
+        if (app == null || prefs()?.getString(KEY_MODE, MODE_AUTO) == MODE_DIRECT) return
+        if (!probing.compareAndSet(false, true)) return
+        val now = System.currentTimeMillis()
+        if (now - probedAt.get() < PROBE_COOLDOWN_MS) {
+            probing.set(false)
+            return
+        }
+        probedAt.set(now)
+        Thread {
+            try {
+                val times = ConcurrentHashMap<String, Long>()
+                val sources = listOf<String?>(null) + MIRRORS.map { it.host }
+                val latch = CountDownLatch(sources.size)
+                for (mirror in sources) {
+                    Thread {
+                        try {
+                            val ms = latency(mirror?.let { "https://$it/$PROBE" } ?: PROBE)
+                            if (ms > 0) times[mirror ?: ""] = ms
+                        } finally {
+                            latch.countDown()
+                        }
+                    }.apply { isDaemon = true }.start()
+                }
+                latch.await(PROBE_TIMEOUT_MS * 3L, TimeUnit.MILLISECONDS)
+                val best = times.minByOrNull { it.value }?.key ?: return@Thread
+                lastGood = best
+                prefs()?.edit()?.putString(KEY_FASTEST, best)?.apply()
+            } finally {
+                probing.set(false)
+            }
+        }.apply { isDaemon = true }.start()
+    }
+
+    private fun latency(url: String): Long {
+        val started = System.nanoTime()
+        var connection: HttpURLConnection? = null
+        return try {
+            val c = (URL(url).openConnection() as HttpURLConnection).apply {
+                connectTimeout = PROBE_TIMEOUT_MS
+                readTimeout = PROBE_TIMEOUT_MS
+                instanceFollowRedirects = true
+                setRequestProperty("Range", "bytes=0-1023")
+                setRequestProperty("User-Agent", UA)
+            }
+            connection = c
+            if (c.responseCode / 100 != 2) 0L else {
+                c.inputStream.use { it.read() }
+                (System.nanoTime() - started) / 1_000_000
+            }
+        } catch (e: Exception) {
+            0L
+        } finally {
+            runCatching { connection?.disconnect() }
+        }
+    }
+
+    fun isGithub(url: String): Boolean = GITHUB_HOSTS.any { url.startsWith("https://$it/") }
+
+    /** Catalogs carry the digests everything else is checked against, so a mirror must never supply one. */
+    fun isCatalog(url: String): Boolean = CATALOGS.any { url.startsWith(it) }
+
+    fun candidates(target: String): List<String> {
+        // GitHub API metadata carries executable URLs and digests; never proxy it.
+        if (isCatalog(target) || target.startsWith("https://api.github.com/")) return listOf(target)
+        val prefs = prefs() ?: return listOf(target)
+        if (!isGithub(target)) return listOf(target)
+        val api = target.startsWith("https://api.github.com/")
+        val proxies = MIRRORS.filter { !api || it.api }.map { it.proxy(target) }
+        val ordered = when (prefs.getString(KEY_MODE, MODE_AUTO) ?: MODE_AUTO) {
+            MODE_DIRECT -> listOf(target)
+            MODE_MIRROR -> listOfNotNull(picked(prefs, api)?.proxy(target)) + listOf(target) + quickest(proxies)
+            MODE_CUSTOM -> listOfNotNull(customProxy(prefs, target)) + listOf(target) + quickest(proxies)
+            else -> if (api) listOf(target) else listOf(target) + quickest(proxies)
+        }
+        return ordered.distinct()
+    }
+
+    private fun quickest(sources: List<String>): List<String> =
+        sources.sortedBy { if (host(it) == lastGood) 0 else 1 }
+
+    fun succeeded(source: String) {
+        lastGood = host(source)
+    }
+
+    fun failed() {
+        lastGood = null
+        prefs()?.edit()?.remove(KEY_FASTEST)?.apply()
+    }
+
+    fun mode(context: Context): String = prefs(context)?.getString(KEY_MODE, MODE_AUTO) ?: MODE_AUTO
+
+    fun setMode(context: Context, mode: String) {
+        prefs(context)?.edit()?.putString(KEY_MODE, mode.takeIf { it in MODES } ?: MODE_AUTO)?.apply()
+    }
+
+    fun mirror(context: Context): String {
+        val host = prefs(context)?.getString(KEY_MIRROR, "") ?: ""
+        return MIRRORS.firstOrNull { it.host == host }?.host ?: MIRRORS.first().host
+    }
+
+    fun setMirror(context: Context, host: String) {
+        prefs(context)?.edit()?.putString(KEY_MIRROR, host.takeIf { h -> MIRRORS.any { it.host == h } } ?: "")?.apply()
+    }
+
+    fun custom(context: Context): String = prefs(context)?.getString(KEY_CUSTOM, "") ?: ""
+
+    fun setCustom(context: Context, prefix: String) {
+        prefs(context)?.edit()?.putString(KEY_CUSTOM, normalizePrefix(prefix))?.apply()
+    }
+
+    fun reset(context: Context) {
+        lastGood = null
+        prefs(context)?.edit()?.clear()?.apply()
+    }
+
+    private fun prefs(): SharedPreferences? = app?.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+
+    private fun prefs(context: Context): SharedPreferences? =
+        context.applicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+
+    private fun Mirror.proxy(target: String): String = "https://$host/$target"
+
+    private fun host(url: String): String =
+        MIRRORS.firstOrNull { url.startsWith("https://${it.host}/") }?.host ?: ""
+
+    private fun picked(prefs: SharedPreferences, api: Boolean): Mirror? {
+        val chosen = MIRRORS.firstOrNull { it.host == (prefs.getString(KEY_MIRROR, "") ?: "") } ?: MIRRORS.firstOrNull()
+        return if (api && chosen != null && !chosen.api) MIRRORS.firstOrNull { it.api } else chosen
+    }
+
+    private fun custom(prefs: SharedPreferences): String = prefs.getString(KEY_CUSTOM, "") ?: ""
+
+    private fun customProxy(prefs: SharedPreferences, target: String): String? =
+        normalizePrefix(custom(prefs)).takeIf { it.isNotEmpty() }?.let { "$it/$target" }
+
+    private fun normalizePrefix(value: String): String {
+        val trimmed = value.trim().trimEnd('/')
+        if (trimmed.isEmpty() || trimmed.startsWith("http://")) return ""
+        return if (trimmed.startsWith("https://")) trimmed else "https://$trimmed"
+    }
+}

app/src/main/java/com/droiddeck/launcher/core/Downloader.java

@@ -6,69 +6,201 @@ import java.io.BufferedInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.HttpURLConnection;
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.Properties;
 
 public final class Downloader {
     private static final String TAG = "Downloader";
-    private static final int TIMEOUT_MS = 30_000;
+    private static final int CONNECT_TIMEOUT_MS = 10_000;
+    private static final int STALL_TIMEOUT_MS = 15_000;
+    private static final int HTTP_RANGE_NOT_SATISFIABLE = 416;
 
     private Downloader() {}
 
     public static String downloadString(String url) {
-        HttpURLConnection connection = null;
-        try {
-            connection = open(url);
-            if (connection.getResponseCode() / 100 != 2) {
-                Log.w(TAG, url + " -> HTTP " + connection.getResponseCode());
-                return null;
+        List<String> sources = DownloadSource.INSTANCE.candidates(url);
+        for (int i = 0; i < sources.size(); i++) {
+            if (i > 0) Log.i(TAG, "retrying " + url + " via " + sources.get(i));
+            Fetch fetch = fetch(sources.get(i));
+            if (fetch.body != null) {
+                DownloadSource.INSTANCE.succeeded(sources.get(i));
+                return fetch.body;
             }
-            try (InputStream in = connection.getInputStream();
-                 ByteArrayOutputStream out = new ByteArrayOutputStream()) {
-                FileUtils.copy(in, out);
-                return new String(out.toByteArray(), StandardCharsets.UTF_8);
-            }
-        } catch (Exception e) {
-            Log.w(TAG, "GET " + url, e);
-            return null;
-        } finally {
-            if (connection != null) connection.disconnect();
+            if (fetch.fatal && sources.get(i).equals(url)) return null;
         }
+        DownloadSource.INSTANCE.failed();
+        return null;
+    }
+
+    /** Fetches without the mirror list, for a URL whose body is a digest the payload is checked against. */
+    public static String downloadDirect(String url) {
+        return fetch(url).body;
     }
 
     public static boolean downloadFile(String url, File destination, boolean resume,
                                        java.util.function.Consumer<Float> progress) {
+        return downloadFile(url, destination, resume, null, progress);
+    }
+
+    /** Verify each candidate before accepting it, so a bad mirror can fall back. */
+    public static boolean downloadFile(String url, File destination, boolean resume, String expectedSha256,
+                                       java.util.function.Consumer<Float> progress) {
+        if (expectedSha256 != null && !expectedSha256.matches("(?i)[0-9a-f]{64}"))
+            throw new IllegalArgumentException("Expected SHA-256 must be 64 hex characters");
+        return downloadCandidates(url, DownloadSource.INSTANCE.candidates(url), destination, resume, expectedSha256, progress);
+    }
+
+    // Package-private for the local multi-source HTTP test.
+    static boolean downloadCandidates(String original, List<String> sources, File destination, boolean resume,
+                                      String expectedSha256, java.util.function.Consumer<Float> progress) {
+        Identity identity = loadIdentity(destination, resume, expectedSha256);
+        for (int i = 0; i < sources.size(); i++) {
+            String source = sources.get(i);
+            if (i > 0) Log.i(TAG, "retrying " + original + " via " + source);
+            Outcome outcome = attempt(source, destination, resume, identity, expectedSha256, progress);
+            if (outcome == Outcome.DONE) {
+                if (expectedSha256 != null && !expectedSha256.equalsIgnoreCase(Hashes.sha256(destination))) {
+                    Log.w(TAG, "checksum mismatch from " + source + "; trying another source");
+                    if (!discardPartial(destination, identity)) return false;
+                    continue;
+                }
+                resumeFile(destination).delete();
+                DownloadSource.INSTANCE.succeeded(source);
+                if (progress != null) progress.accept(1f);
+                return true;
+            }
+            if (outcome == Outcome.FATAL && source.equals(original)) return false;
+        }
+        DownloadSource.INSTANCE.failed();
+        return false;
+    }
+
+    private enum Outcome { DONE, RETRY, FATAL }
+
+    private static final class Identity {
+        private String source;
+        private String etag;
+    }
+
+    private static File resumeFile(File dest) {
+        return new File(dest.getPath() + ".resume.properties");
+    }
+
+    private static boolean strongETag(String value) {
+        return value != null && !value.isEmpty() && !value.startsWith("W/");
+    }
+
+    /** Only reuse saved bytes when we persisted a strong validator and their source. */
+    private static Identity loadIdentity(File dest, boolean resume, String expectedSha256) {
+        Identity identity = new Identity();
+        File marker = resumeFile(dest);
+        if (!resume || !dest.isFile() || dest.length() == 0) {
+            marker.delete();
+            return identity;
+        }
+        try (FileInputStream in = new FileInputStream(marker)) {
+            Properties p = new Properties();
+            p.load(in);
+            String source = p.getProperty("source");
+            String etag = p.getProperty("etag");
+            String expected = p.getProperty("sha256", "");
+            if (source != null && source.startsWith("http") && strongETag(etag)
+                    && expected.equals(expectedSha256 == null ? "" : expectedSha256.toLowerCase(java.util.Locale.ROOT))) {
+                identity.source = source;
+                identity.etag = etag;
+                return identity;
+            }
+        } catch (IOException e) {
+            // Legacy partials or interrupted metadata writes have no trustworthy identity.
+        }
+        if (!discardPartial(dest, identity)) Log.w(TAG, "could not discard unidentified partial " + dest);
+        return identity;
+    }
+
+    private static boolean discardPartial(File dest, Identity identity) {
+        identity.source = null;
+        identity.etag = null;
+        File marker = resumeFile(dest);
+        return (!dest.exists() || dest.delete()) && (!marker.exists() || marker.delete());
+    }
+
+    private static void saveIdentity(File dest, Identity identity, String expectedSha256) {
+        File marker = resumeFile(dest);
+        if (!strongETag(identity.etag)) {
+            marker.delete();
+            return;
+        }
+        Properties p = new Properties();
+        p.setProperty("source", identity.source);
+        p.setProperty("etag", identity.etag);
+        p.setProperty("sha256", expectedSha256 == null ? "" : expectedSha256.toLowerCase(java.util.Locale.ROOT));
+        try (FileOutputStream out = new FileOutputStream(marker)) {
+            p.store(out, "DroidDeck partial download validator");
+        } catch (IOException e) {
+            marker.delete(); // No valid metadata means no future resume.
+            Log.w(TAG, "cannot persist download validator", e);
+        }
+    }
+
+    private static Outcome attempt(String url, File destination, boolean resume, Identity identity,
+                                   String expectedSha256, java.util.function.Consumer<Float> progress) {
         HttpURLConnection connection = null;
         long have = resume && destination.isFile() ? destination.length() : 0;
         try {
-            connection = open(url);
-            if (have > 0) connection.setRequestProperty("Range", "bytes=" + have + "-");
+            if (have > 0 && (!url.equals(identity.source) || !strongETag(identity.etag))) {
+                // A new source or unvalidated bytes must restart from byte zero.
+                if (!discardPartial(destination, identity)) return Outcome.RETRY;
+                have = 0;
+            }
+            connection = open(url, STALL_TIMEOUT_MS);
+            if (have > 0) {
+                connection.setRequestProperty("Range", "bytes=" + have + "-");
+                connection.setRequestProperty("If-Range", identity.etag);
+            }
             int code = connection.getResponseCode();
-            boolean appending = code == HttpURLConnection.HTTP_PARTIAL;
-            if (appending && !rangeStartsAt(connection.getHeaderField("Content-Range"), have)) {
-                // A 206 that does not begin where the kept bytes end would corrupt the file if appended.
+            if (have > 0 && code == HTTP_RANGE_NOT_SATISFIABLE) {
                 connection.disconnect();
-                destination.delete();
-                return downloadFile(url, destination, false, progress);
+                if (!discardPartial(destination, identity)) return Outcome.RETRY;
+                return attempt(url, destination, false, identity, expectedSha256, progress);
             }
             if (code / 100 != 2) {
-                if (have > 0) {
-                    connection.disconnect();
-                    destination.delete();
-                    return downloadFile(url, destination, false, progress);
-                }
                 Log.w(TAG, url + " -> HTTP " + code);
-                return false;
+                return code == HttpURLConnection.HTTP_NOT_FOUND || code == HttpURLConnection.HTTP_GONE
+                        ? Outcome.FATAL : Outcome.RETRY;
+            }
+            boolean appending = code == HttpURLConnection.HTTP_PARTIAL;
+            if (appending && !rangeStartsAt(connection.getHeaderField("Content-Range"), have)) {
+                connection.disconnect();
+                if (!discardPartial(destination, identity)) return Outcome.RETRY;
+                return attempt(url, destination, false, identity, expectedSha256, progress);
+            }
+            String etag = connection.getHeaderField("ETag");
+            if (have > 0 && appending && (!strongETag(etag) || !etag.equals(identity.etag))) {
+                connection.disconnect();
+                if (!discardPartial(destination, identity)) return Outcome.RETRY;
+                return attempt(url, destination, false, identity, expectedSha256, progress);
+            }
+            if (!appending && have > 0) {
+                // If-Range may legitimately return full 200 when representation changed.
+                if (!discardPartial(destination, identity)) return Outcome.RETRY;
+                have = 0;
             }
             if (!appending) have = 0;
             long length = connection.getContentLengthLong();
-            long total = length < 0 ? -1 : length + have;
+            long total = appending ? rangeTotal(connection.getHeaderField("Content-Range")) : -1;
+            if (total < 0) total = length < 0 ? -1 : length + have;
             File parent = destination.getParentFile();
-            if (parent != null && !parent.isDirectory())
-                parent.mkdirs();
+            if (parent != null && !parent.isDirectory()) parent.mkdirs();
+            identity.source = url;
+            identity.etag = strongETag(etag) ? etag : null;
+            saveIdentity(destination, identity, expectedSha256);
             long written = have;
             try (InputStream in = new BufferedInputStream(connection.getInputStream(), 1 << 16);
                  OutputStream out = new FileOutputStream(destination, appending)) {
@@ -83,11 +215,11 @@ public final class Downloader {
                     }
                 }
             }
-            if (progress != null) progress.accept(1f);
-            return total <= 0 || written >= total;
+            if (total > 0 && written < total) return Outcome.RETRY;
+            return Outcome.DONE;
         } catch (Exception e) {
             Log.w(TAG, "download " + url, e);
-            return false;
+            return Outcome.RETRY;
         } finally {
             if (connection != null) connection.disconnect();
         }
@@ -100,10 +232,49 @@ public final class Downloader {
         return m.matches() && Long.parseLong(m.group(1)) == start;
     }
 
-    private static HttpURLConnection open(String url) throws java.io.IOException {
+    /** The complete length in a `Content-Range` header, or -1 when the header leaves it unknown. */
+    static long rangeTotal(String contentRange) {
+        if (contentRange == null) return -1;
+        java.util.regex.Matcher m = java.util.regex.Pattern.compile("^\\s*bytes\\s+\\d+-\\d+/(\\d+)\\s*$").matcher(contentRange);
+        return m.matches() ? Long.parseLong(m.group(1)) : -1;
+    }
+
+    private static final class Fetch {
+        final String body;
+        final boolean fatal;
+
+        Fetch(String body, boolean fatal) {
+            this.body = body;
+            this.fatal = fatal;
+        }
+    }
+
+    private static Fetch fetch(String url) {
+        HttpURLConnection connection = null;
+        try {
+            connection = open(url, STALL_TIMEOUT_MS);
+            int code = connection.getResponseCode();
+            if (code / 100 != 2) {
+                Log.w(TAG, url + " -> HTTP " + code);
+                return new Fetch(null, code == HttpURLConnection.HTTP_NOT_FOUND || code == HttpURLConnection.HTTP_GONE);
+            }
+            try (InputStream in = connection.getInputStream();
+                 ByteArrayOutputStream out = new ByteArrayOutputStream()) {
+                FileUtils.copy(in, out);
+                return new Fetch(new String(out.toByteArray(), StandardCharsets.UTF_8), false);
+            }
+        } catch (Exception e) {
+            Log.w(TAG, "GET " + url, e);
+            return new Fetch(null, false);
+        } finally {
+            if (connection != null) connection.disconnect();
+        }
+    }
+
+    private static HttpURLConnection open(String url, int readTimeoutMs) throws java.io.IOException {
         HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
-        connection.setConnectTimeout(TIMEOUT_MS);
-        connection.setReadTimeout(TIMEOUT_MS);
+        connection.setConnectTimeout(CONNECT_TIMEOUT_MS);
+        connection.setReadTimeout(readTimeoutMs);
         connection.setInstanceFollowRedirects(true);
         connection.setRequestProperty("User-Agent", "DroidDeck-Android");
         return connection;

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

@@ -1,5 +1,7 @@
 package com.droiddeck.launcher.core
 
+import com.droiddeck.launcher.session.SessionPrefs
+
 object GameEnvironment {
     data class Config(
         val shared: Map<String, String?> = emptyMap(),
@@ -83,4 +85,34 @@ object GameEnvironment {
     }
 
     const val CUSTOM_FEX_PRESET = "__custom__"
+
+    val syncBackends = listOf(SessionPrefs.SYNC_NTSYNC, SessionPrefs.SYNC_FSYNC, SessionPrefs.SYNC_ESYNC, SessionPrefs.SYNC_WINESERVER)
+
+    val syncKeys = listOf("BL_SYNC", "BL_FSYNC_FIRST", "BL_SYNC_FALLBACK", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC", "PROTON_NO_NTSYNC", "WINEESYNC")
+
+    fun syncEnvironment(backend: String): Map<String, String> {
+        require(backend in syncBackends) { "unknown sync $backend" }
+        return buildMap {
+            put("BL_SYNC", if (backend == SessionPrefs.SYNC_NTSYNC) "1" else "0")
+            put("BL_FSYNC_FIRST", if (backend == SessionPrefs.SYNC_FSYNC) "1" else "0")
+            put("BL_SYNC_FALLBACK", if (backend == SessionPrefs.SYNC_WINESERVER) "0" else "1")
+            if (backend == SessionPrefs.SYNC_FSYNC) put("PROTON_NO_ESYNC", "1")
+        }
+    }
+
+    fun gameSync(config: Config, scope: String): String? {
+        require(scope.isNotEmpty() && validScope(scope))
+        val entries = config.games[scope].orEmpty().filterKeys { it in syncKeys }
+        if (entries.isEmpty()) return null
+        return syncBackends.firstOrNull { entries == syncEnvironment(it) } ?: CUSTOM_SYNC
+    }
+
+    fun withGameSync(config: Config, scope: String, backend: String?): Config {
+        require(scope.isNotEmpty() && validScope(scope))
+        val entries = config.entries(scope).filterKeys { it !in syncKeys }.toMutableMap()
+        if (backend != null) entries += syncEnvironment(backend)
+        return config.withEntries(scope, entries)
+    }
+
+    const val CUSTOM_SYNC = "__custom__"
 }

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

@@ -51,25 +51,29 @@ object LogRedactor {
     @Volatile
     private var accounts: List<Learned> = emptyList()
 
-    fun learnAccounts(loginUsers: java.io.File) {
-        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 ->
-                    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) {
-            return
+    fun learnAccounts(vararg loginUsers: java.io.File) {
+        val names = LinkedHashSet<String>()
+        val kv = Regex("\"(AccountName|PersonaName)\"\\s+\"([^\"]*)\"")
+        var unread = false
+        for (file in loginUsers) {
+            if (!file.isFile) continue
+            val text = try { file.readText() } catch (e: Exception) { unread = true; continue }
+            kv.findAll(text).map { it.groupValues[2].trim() }.filter { it.length >= 3 }.forEach { names += it }
         }
-        accounts = found
+        val learned = names.map { name ->
+            val needs = name.lowercase().takeIf { name.all { it.code < 0x80 } }
+            Learned(Regex("(?i)(?<![A-Za-z0-9_])" + Regex.escape(name) + "(?![A-Za-z0-9_])"), needs)
+        }
+        // A file that could not be read keeps the names learned from it before.
+        accounts = if (unread) (accounts + learned).distinctBy { it.regex.pattern } else learned
     }
 
     fun learnFromRuntime(root: java.io.File) {
         learnOwnAddresses(java.io.File(root, "etc/droiddeck-net"))
-        learnAccounts(java.io.File(root, "root/.local/share/Steam/config/loginusers.vdf"))
+        learnAccounts(
+            java.io.File(root, "root/.local/share/Steam/config/loginusers.vdf"),
+            java.io.File(root, "root/.droiddeck-x64/.local/share/Steam/config/loginusers.vdf"),
+        )
     }
 
     @Volatile

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

@@ -26,10 +26,12 @@ object PhantomProcessLimit {
         usesDeviceConfig(sdk) && enabled -> listOf(
             "device_config delete activity_manager max_phantom_processes",
             "device_config set_sync_disabled_for_tests none",
+            "settings put global $SETTING true",
         )
         usesDeviceConfig(sdk) -> listOf(
             "device_config set_sync_disabled_for_tests persistent",
             "device_config put activity_manager max_phantom_processes $MAX_PHANTOM",
+            "settings put global $SETTING false",
         )
         else -> listOf("settings put global $SETTING ${if (enabled) "true" else "false"}")
     }
@@ -57,7 +59,12 @@ object PhantomProcessLimit {
         if (sdk < Build.VERSION_CODES.S) return PhantomProcessStatus.NOT_APPLICABLE
         if (usesDeviceConfig(sdk)) {
             val off = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).getBoolean(PREF_ANDROID_12_OFF, false)
-            return if (off) PhantomProcessStatus.DISABLED else PhantomProcessStatus.UNREADABLE
+            val global = try {
+                Settings.Global.getString(context.contentResolver, SETTING)
+            } catch (_: Exception) {
+                null
+            }
+            return android12Status(off, global, systemProperty(OVERRIDE_PROPERTY))
         }
         val global = try {
             Settings.Global.getString(context.contentResolver, SETTING)
@@ -67,6 +74,10 @@ object PhantomProcessLimit {
         return status(global, systemProperty(OVERRIDE_PROPERTY))
     }
 
+    fun android12Status(rememberedOff: Boolean, global: String?, override: String?): PhantomProcessStatus =
+        if (rememberedOff || status(global, override) == PhantomProcessStatus.DISABLED) PhantomProcessStatus.DISABLED
+        else PhantomProcessStatus.UNREADABLE
+
     fun status(global: String?, override: String?): PhantomProcessStatus {
         val value = global?.trim()?.lowercase()?.takeIf { it.isNotEmpty() }
             ?: override?.trim()?.lowercase()?.takeIf { it.isNotEmpty() }

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

@@ -4,6 +4,7 @@ import android.os.Process
 import android.util.Log
 import java.io.BufferedWriter
 import java.io.File
+import java.io.FileOutputStream
 
 object SessionLogCapture {
     private const val TAG = "SessionLogCapture"
@@ -11,6 +12,7 @@ object SessionLogCapture {
     private var pid = -1
     private var writer: BufferedWriter? = null
     private var target: File? = null
+    private var syncer: Thread? = null
 
     @Synchronized
     fun start(target: File) {
@@ -37,6 +39,7 @@ object SessionLogCapture {
                 out.write("logcat could not be started; this ROM may not hand an app its own entries.\n")
                 out.flush()
             }
+            target.parentFile?.let { syncer = startSyncing(it) }
             Log.i(TAG, "app log -> $target (logcat pid $pid)")
         } catch (e: Exception) {
             Log.w(TAG, "could not start the app log", e)
@@ -49,8 +52,19 @@ object SessionLogCapture {
         if (t.parentFile?.absolutePath == dir.absolutePath) stop()
     }
 
+    /** flush() only reaches the page cache, and a hard reset on f2fs lost the last minutes of every
+     *  log. Every 2 s the session folder's files (ours and the native parts') are synced to storage. */
+    private fun startSyncing(dir: File): Thread = Thread({
+        while (true) {
+            try { Thread.sleep(2000) } catch (e: InterruptedException) { break }
+            dir.listFiles()?.forEach { runCatching { FileOutputStream(it, true).use { s -> s.fd.sync() } } }
+        }
+    }, "session-log-sync").apply { isDaemon = true; start() }
+
     @Synchronized
     fun stop() {
+        syncer?.interrupt()
+        syncer = null
         target = null
         if (pid != -1) {
             try {

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

@@ -22,7 +22,7 @@ object AddedGameArt {
     }
 
     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),
+        COVER("p", "p.jpg", 0), WIDE("header", "header.jpg", 3), BACKGROUND("hero", "hero.jpg", 1), LOGO("logo", "logo.png", 2), ICON("icon", "icon.png", null),
     }
 
     const val FOLDER = "folder"
@@ -40,10 +40,10 @@ object AddedGameArt {
 
     class Found<T>(val items: List<T>, val status: SteamGridDb.Status)
 
-    private val CHOSEN = Regex("""chosen-(\w+)\.(\w+)""")
+    private val CHOSEN = Regex("""chosen-(p|header|hero|logo|icon)(?:-\d+)?\.(\w+)""")
 
-    private fun chosen(cache: File, slot: Slot): File? =
-        cache.listFiles { f -> CHOSEN.matchEntire(f.name)?.groupValues?.get(1) == slot.key }?.firstOrNull()
+    internal fun chosen(cache: File, slot: Slot): File? =
+        cache.listFiles { f -> CHOSEN.matchEntire(f.name)?.groupValues?.get(1) == slot.key }?.maxWithOrNull(compareBy({ it.lastModified() }, { it.name }))
 
     private val IMAGE = listOf("png", "jpg", "jpeg")
     private val PORTRAIT = listOf("cover", "poster", "grid", "boxart", "capsule", "folder", "library_600x900", "portrait")
@@ -79,7 +79,7 @@ object AddedGameArt {
         fun cached(name: String) = File(cache, name).takeIf { it.isFile }
         return Art(
             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),
+            header = chosen(cache, Slot.WIDE) ?: 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),
@@ -96,6 +96,7 @@ object AddedGameArt {
             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.WIDE -> own.header?.let { it to FOLDER } ?: cached("header.jpg") ?: exeArt(context, game, cover = false)?.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 }
@@ -117,36 +118,37 @@ object AddedGameArt {
         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))
-        }
-        var status = SteamGridDb.Status.OK
-        val key = SteamGridDb.key(context)
-        if (key.isEmpty()) {
-            status = SteamGridDb.Status.NO_KEY
-        } else {
-            cache.mkdirs()
-            try {
-                val gridId = remembered(File(cache, "sgdb-id"), SteamGridDb.keyChangedAt(context), retryMiss = true) {
-                    SteamGridDb.gameId(key, steamId?.toIntOrNull(), game.name)?.toString()
-                }?.toIntOrNull()
-                if (gridId == null) status = SteamGridDb.Status.NO_GAME
-                else SteamGridDb.images(key, gridId, slot, if (slot == Slot.ICON) 3 else 5)
-                    .forEach { (thumb, full) -> out.add(Option(SGDB, thumb, full)) }
-            } catch (e: Exception) {
-                Log.w(TAG, "${game.name}: SteamGridDB failed (${e.javaClass.simpleName})")
-                status = (e as? SteamGridDb.Failed)?.status ?: SteamGridDb.Status.SERVER
-            }
-        }
+        if (steamId != null) steamOption(steamId, slot)?.let { out.add(it) }
+        val (found, status) = sgdbChoices(context, File(cache, "sgdb-id"), steamId?.toIntOrNull(), game.name, slot)
+        out.addAll(found)
         return Choices(out, status)
     }
 
+    internal fun steamOption(steamId: String, slot: Slot): Option? {
+        val remote = when (slot) { Slot.COVER -> "library_600x900.jpg"; Slot.WIDE -> "header.jpg"; Slot.BACKGROUND -> "library_hero.jpg"; Slot.LOGO -> "logo.png"; Slot.ICON -> null } ?: return null
+        val url = "$CDN$steamId/$remote".takeIf { exists(it) } ?: steamAssetUrl(steamId, remote) ?: return null
+        return Option(STEAM, url, url)
+    }
+
+    internal fun sgdbChoices(context: Context, marker: File, steamId: Int?, name: String, slot: Slot): Pair<List<Option>, SteamGridDb.Status> {
+        val key = SteamGridDb.key(context)
+        if (key.isEmpty()) return emptyList<Option>() to SteamGridDb.Status.NO_KEY
+        marker.parentFile?.mkdirs()
+        return try {
+            val gridId = remembered(marker, SteamGridDb.keyChangedAt(context), retryMiss = true) {
+                SteamGridDb.gameId(key, steamId, name)?.toString()
+            }?.toIntOrNull() ?: return emptyList<Option>() to SteamGridDb.Status.NO_GAME
+            SteamGridDb.images(key, gridId, slot, if (slot == Slot.ICON) 3 else 5).map { (thumb, full) -> Option(SGDB, thumb, full) } to SteamGridDb.Status.OK
+        } catch (e: Exception) {
+            Log.w(TAG, "$name: SteamGridDB failed (${e.javaClass.simpleName})")
+            emptyList<Option>() to ((e as? SteamGridDb.Failed)?.status ?: SteamGridDb.Status.SERVER)
+        }
+    }
+
     fun searchGames(context: Context, term: String): Found<SteamGridDb.Game> = sgdb(context) { SteamGridDb.search(it, term) }
 
-    fun gameImages(context: Context, id: Int, slot: Slot, page: Int): Found<Option> = sgdb(context) { key ->
-        SteamGridDb.page(key, id, slot, page).map { (thumb, full) -> Option(SGDB, thumb, full) }
+    fun gameImages(context: Context, id: Int, slot: Slot): Found<Option> = sgdb(context) { key ->
+        SteamGridDb.all(key, id, slot).map { (thumb, full) -> Option(SGDB, thumb, full) }
     }
 
     private fun <T> sgdb(context: Context, call: (String) -> List<T>): Found<T> {
@@ -161,19 +163,38 @@ object AddedGameArt {
     }
 
     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
+        if (!store(cacheDir(context, game), slot, option)) return false
         SessionPrefs.setAddedGameArtSource(context, game.folder.path, slot.key, option.group + "|" + option.full)
         return true
     }
 
+    internal fun store(cache: File, slot: Slot, option: Option): Boolean {
+        val fresh = storeNew(cache, slot, option) ?: return false
+        dropOlder(cache, slot, fresh)
+        return true
+    }
+
+    internal fun dropOlder(cache: File, slot: Slot, keep: File) {
+        cache.listFiles { f -> f != keep && CHOSEN.matchEntire(f.name)?.groupValues?.get(1) == slot.key }?.forEach { it.delete() }
+    }
+
+    private val lastStamp = java.util.concurrent.atomic.AtomicLong(0)
+
+    private fun nextStamp(): Long = lastStamp.updateAndGet { maxOf(it + 1, System.currentTimeMillis()) }
+
+    internal fun storeNew(cache: File, slot: Slot, option: Option): File? {
+        val bytes = if (option.full.startsWith("https://")) get(option.full) else runCatching { File(option.full).readBytes() }.getOrNull()
+        bytes ?: return null
+        val ext = option.full.substringAfterLast('.', "png").substringBefore('?').lowercase().takeIf { it in CHOOSABLE + "ico" } ?: "png"
+        cache.mkdirs()
+        val suffix = if (ext == "jpeg") "jpg" else ext
+        var dst = File(cache, "chosen-${slot.key}-" + "%013d".format(nextStamp()) + "." + suffix)
+        while (dst.exists()) dst = File(cache, "chosen-${slot.key}-" + "%013d".format(nextStamp()) + "." + suffix)
+        val tmp = File(cache, dst.name + ".tmp")
+        tmp.writeBytes(bytes)
+        return if (tmp.renameTo(dst)) dst else null
+    }
+
     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('|', "")

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

@@ -36,19 +36,34 @@ object AddedGameEdits {
 
     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
+        return synchronized(SteamGrid.lock) {
+            if (!AddedGameArt.choose(context, game, slot, option)) return@synchronized false
+            applyArt(context, game, slot)
+            true
+        }
     }
 
     fun resetArt(context: Context, folder: String, slot: AddedGameArt.Slot) {
         val game = game(context, folder) ?: return
-        AddedGameArt.reset(context, game, slot)
-        applyArt(context, game, slot)
+        synchronized(SteamGrid.lock) {
+            AddedGameArt.reset(context, game, slot)
+            applyArt(context, game, slot)
+        }
+    }
+
+    fun logoPosition(context: Context, folder: String): LogoPosition.Value? =
+        game(context, folder)?.let { SteamGrid.position(SteamGrid.target(it, context)) }
+
+    fun setLogoPosition(context: Context, folder: String, value: LogoPosition.Value?): Boolean {
+        val game = game(context, folder) ?: return false
+        if (!SteamGrid.writePosition(context, SteamGrid.target(game, context), value)) return false
+        publish(context) { SteamLiveShortcuts.setLogoPosition(context, game.appId, value) }
+        return true
     }
 
     private fun applyArt(context: Context, game: AddedGames.Game, slot: AddedGameArt.Slot) {
         val file = AddedGameArt.describe(context, game).first { it.slot == slot }.file
+        if (slot != AddedGameArt.Slot.ICON) SteamGrid.write(context, SteamGrid.target(game, context), slot, AddedGameArt.chosen(AddedGameArt.cacheDir(context, game), slot))
         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)

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

@@ -6,6 +6,7 @@ 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.Store
 import com.droiddeck.launcher.stores.StoreGameSidecar
 import com.droiddeck.launcher.stores.StoreInstallRoot
 import java.io.File
@@ -138,6 +139,10 @@ object AddedGames {
         "appxmanifest.xml" to Regex("<Application\\b[^>]*?\\bExecutable\\s*=\\s*\"([^\"]+)\"", RegexOption.IGNORE_CASE),
     )
 
+    /** The card's Steam libraries: the arm64 client's steamapps and the x86-64 client's own folder beside it. */
+    internal fun isSteamLibraryFolder(name: String): Boolean =
+        name.equals("steamapps", ignoreCase = true) || name == com.droiddeck.launcher.session.GameStorage.X64_CARD_DIR
+
     fun scan(context: Context): List<Game> {
         val out = ArrayList<Game>()
         GamesFolderMigration.run(context)
@@ -150,7 +155,7 @@ object AddedGames {
             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 || folder.name.equals("steamapps", ignoreCase = true)) continue
+                if (folder.name.lowercase() in steamInstalls || isSteamLibraryFolder(folder.name)) continue
                 if (folder.path in removed) continue
                 if (folder.name == "Games" && StoreInstallRoot.roots(context).any { it.absolutePath == folder.absolutePath }) continue
                 scanGame(context, folder, out)
@@ -210,7 +215,7 @@ object AddedGames {
             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 }
+            File(dir, first).takeIf { it.isDirectory && !isSteamLibraryFolder(first) }?.let { return it }
         }
         return null
     }
@@ -270,7 +275,7 @@ object AddedGames {
         )
         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.path in removed || isSteamLibraryFolder(folder.name)) continue
                 if (folder.name == "Games" && StoreInstallRoot.roots(context).any { it.absolutePath == folder.absolutePath }) continue
                 out.add(canonical(folder))
             }
@@ -296,19 +301,22 @@ object AddedGames {
     private fun scanGame(context: Context, folder: File, out: MutableList<Game>, single: AddedExes.Entry? = null) {
         run {
             val sidecar = StoreGameSidecar.read(folder)
+            sidecar?.takeIf { it.id.isNotEmpty() }?.let { SessionPrefs.followStoreGame(context, "${it.store.id}:${it.id}", folder.path) { old -> !File(old).exists() } }
             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 }
             val found = chosen ?: sidecar?.exeFile(folder)?.takeIf { it.isFile } ?: candidates.firstOrNull() ?: return
-            val launch = if (chosen == null) sidecar?.launcherFile(folder)?.takeIf { it.isFile } ?: found else found
+            val epicLauncher = sidecar?.takeIf { it.store == Store.EPIC && (chosen == null || canonical(chosen) == canonical(it.exeFile(folder))) }
+                ?.launcherFile(folder)?.takeIf { it.isFile }
+            val launch = epicLauncher ?: 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 }
             val autoName = sidecar?.title ?: identifiedName(folder, found) ?: folder.name
             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 config = accountConfig(SessionPrefs.activeSteamRoot(context))
             val record = config?.let { shortcutRecord(it, appId) }
             val rev = record?.optInt("rev", 0) ?: 0
             if (sidecar == null && record != null) adoptSteamEdits(context, folder, record)
@@ -330,7 +338,7 @@ object AddedGames {
         }
     }
 
-    private fun accountConfig(root: File): File? {
+    internal 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]) }
@@ -343,6 +351,9 @@ object AddedGames {
         JSONObject(File(config, ".droiddeck-routes.json").readText()).optInt(appId.toString()).takeIf { it > 0 }
     }.getOrNull()
 
+    fun inSteam(context: Context, appId: Long): Boolean =
+        accountConfig(SessionPrefs.activeSteamRoot(context))?.let { shortcutRecord(it, appId) } != null
+
     private fun shortcutRecord(config: File, appId: Long): JSONObject? = runCatching {
         JSONObject(File(config, ".droiddeck-shortcuts.json").readText()).optJSONObject("games")?.optJSONObject(appId.toString())
     }.getOrNull()
@@ -382,7 +393,8 @@ object AddedGames {
         }
     }
 
-    fun writeListing(context: Context, games: List<Game>): File {
+    fun writeListing(context: Context, games: List<Game>,
+        extra: List<JSONObject> = listOfNotNull(com.droiddeck.launcher.stores.epic.EpicClient.steamListing(context))): File {
         val file = File(context.filesDir, "session/added-games.json").apply { parentFile?.mkdirs() }
         val json = StringBuilder("[")
         games.forEachIndexed { i, g ->
@@ -399,6 +411,10 @@ object AddedGames {
             if (pieces.isNotEmpty()) json.append(",\"art\":{").append(pieces.joinToString(",") { (k, v) -> quote(k) + ":" + quote(v) }).append('}')
             json.append('}')
         }
+        extra.forEachIndexed { i, entry ->
+            if (games.isNotEmpty() || i > 0) json.append(',')
+            json.append(entry.toString())
+        }
         file.writeText(json.append(']').toString())
         return file
     }

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

@@ -26,6 +26,7 @@ object AddedGamesPublisher {
     fun republish(context: Context) {
         val games = AddedGames.scan(context)
         AddedGames.writeListing(context, games)
-        LibraryCache.save(context, Library.launchableGames(context, added = games))
+        val arch = com.droiddeck.launcher.session.SessionPrefs.activeSteamClientArch(context)
+        LibraryCache.save(context, Library.launchableGames(context, added = games, arch = arch), arch == "x86_64")
     }
 }

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

@@ -332,7 +332,7 @@ object AutoComponents {
             caps.hasCapability(android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED)
     }
 
-    private fun constrained(context: Context): Boolean {
+    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

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

@@ -3,6 +3,7 @@ package com.droiddeck.launcher.frontend
 import android.content.Context
 import android.graphics.BitmapFactory
 import android.util.Log
+import com.droiddeck.launcher.core.DownloadSource
 import org.json.JSONArray
 import org.json.JSONObject
 import java.io.File
@@ -199,24 +200,62 @@ object CoverArt {
             setRequestProperty("User-Agent", "DroidDeck")
         }
 
-    private fun exists(url: String): Boolean = try {
-        val c = open(url, "HEAD"); val ok = c.responseCode == 200; c.disconnect(); ok
-    } catch (e: Exception) { false }
+    private fun <T> through(url: String, attempt: (String, Boolean) -> T?): T? {
+        for (source in DownloadSource.candidates(url)) {
+            val result = attempt(source, source == url)
+            if (result != null) {
+                DownloadSource.succeeded(source)
+                return result
+            }
+        }
+        DownloadSource.failed()
+        return null
+    }
 
-    private fun get(url: String): String? = try {
+    private fun exists(url: String): Boolean = through(url) { source, original -> head(source, original) } ?: false
+
+    private fun head(url: String, original: Boolean): Boolean? = try {
+        val c = open(url, "HEAD")
+        val code = c.responseCode
+        c.disconnect()
+        when {
+            code == 200 -> true
+            code == 404 || code == 410 -> if (original) false else null
+            else -> null
+        }
+    } catch (e: Exception) { null }
+
+    private fun get(url: String): String? = through(url) { source, original -> text(source, original) }
+
+    private fun text(url: String, original: Boolean): String? = try {
         val c = open(url)
-        if (c.responseCode != 200) { c.disconnect(); null } else c.inputStream.bufferedReader().use { it.readText() }
+        val code = c.responseCode
+        when {
+            code == 200 -> c.inputStream.bufferedReader().use { it.readText() }.takeIf { it.isNotEmpty() }
+            code == 404 || code == 410 -> { c.disconnect(); if (original) "" else null }
+            else -> { c.disconnect(); null }
+        }
     } catch (e: Exception) { Log.w(TAG, "$url: $e"); null }
 
-    private fun download(url: String, target: File): Boolean = try {
+    private fun download(url: String, target: File): Boolean = through(url) { source, original -> fetch(source, target, original) } ?: false
+
+    private fun fetch(url: String, target: File, original: Boolean): Boolean? = try {
         val c = open(url)
-        if (c.responseCode != 200) { c.disconnect(); false } else {
-            target.parentFile?.mkdirs()
-            val tmp = File(target.path + ".part")
-            c.inputStream.use { input -> tmp.outputStream().use { input.copyTo(it) } }
-            val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
-            BitmapFactory.decodeFile(tmp.path, bounds)
-            if (bounds.outWidth > 0 && tmp.renameTo(target)) true else { tmp.delete(); false }
+        when (val code = c.responseCode) {
+            200 -> {
+                target.parentFile?.mkdirs()
+                val tmp = File(target.path + ".part")
+                c.inputStream.use { input -> tmp.outputStream().use { input.copyTo(it) } }
+                val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+                BitmapFactory.decodeFile(tmp.path, bounds)
+                when {
+                    bounds.outWidth > 0 && tmp.renameTo(target) -> true
+                    original -> { tmp.delete(); false }
+                    else -> { tmp.delete(); null }
+                }
+            }
+            404, 410 -> { c.disconnect(); if (original) false else null }
+            else -> { c.disconnect(); null }
         }
-    } catch (e: Exception) { Log.w(TAG, "$url: $e"); false }
+    } catch (e: Exception) { Log.w(TAG, "$url: $e"); null }
 }

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

@@ -38,7 +38,7 @@ object GameFileSync {
 
     @Synchronized private fun sync(context: Context, folder: File) {
         check(LinuxRuntime.isInstalled(context)) { context.getString(R.string.game_sync_err_runtime) }
-        check(File(LinuxRuntime.rootDir(context), "root/.local/share/Steam/steamapps").isDirectory) { context.getString(R.string.game_sync_err_steam_library) }
+        check(File(SessionPrefs.activeSteamRoot(context), "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)

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

@@ -25,7 +25,7 @@ object GamesFolderMigration {
             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 (AddedGames.isSteamLibraryFolder(folder.name) || 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 }

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

@@ -17,10 +17,15 @@ object Library {
         val source: String = SOURCE_STEAM,
         val storeId: String? = null,
     ) {
+        fun withArt(art: File?, hero: File?, icon: File?) =
+            SteamGame(appId, name, art, library, gameId, hero, lastPlayed, gameFiles, protonPrefix, icon, source, storeId)
+
         val gameIdString: String get() = java.lang.Long.toUnsignedString(gameId)
         val profileKey: String get() = if (library == ADDED) java.lang.Integer.toUnsignedString(appId) else appId.toString()
     }
     const val ADDED = "added"
+    const val EPIC_LAUNCHER = "epic-launcher"
+    const val EPIC_LAUNCHER_NAME = "Epic Games Launcher"
     const val SOURCE_STEAM = "steam"
 
     class Rom(val name: String, val hostPath: File, val guestPath: String, val emulatorId: String, val art: File? = null)
@@ -69,11 +74,14 @@ object Library {
     private val LAST_PLAYED = Regex("^\\s*\"LastPlayed\"\\s*\"(\\d+)\"", RegexOption.MULTILINE)
     private val INSTALL_DIR = Regex("^\\s*\"installdir\"\\s*\"([^\"]*)\"", RegexOption.MULTILINE)
 
-    private fun steamLibraries(context: Context): List<Pair<File, String>> {
-        val root = File(LinuxRuntime.rootDir(context), "root/.local/share/Steam")
+    internal fun steamLibraries(context: Context, arch: String = SessionPrefs.activeSteamClientArch(context)): List<Pair<File, String>> {
+        val root = SessionPrefs.steamRoot(context, arch)
+        // The session gives the x86-64 client only its card folder; the games folders stay the arm64 client's.
+        val card = GameStorage.effective(context)
+        if (arch == "x86_64") return listOfNotNull(root to "internal", card?.let { File(it.path, GameStorage.X64_CARD_DIR) to it.label })
         return listOfNotNull(
             root to "internal",
-            GameStorage.effective(context)?.let { File(it.path) to it.label },
+            card?.let { File(it.path) to it.label },
         ) + GameStorage.gamesFolderLibraries(context).map { it.host to it.label }
     }
 
@@ -93,10 +101,10 @@ object Library {
             .firstOrNull { it.isDirectory }
     }
 
-    fun steamGames(context: Context, strictRead: Boolean = false): List<SteamGame> {
-        val root = File(LinuxRuntime.rootDir(context), "root/.local/share/Steam")
+    fun steamGames(context: Context, strictRead: Boolean = false, arch: String = SessionPrefs.activeSteamClientArch(context)): List<SteamGame> {
+        val root = SessionPrefs.steamRoot(context, arch)
         val cache = File(root, "appcache/librarycache")
-        val libraries = steamLibraries(context)
+        val libraries = steamLibraries(context, arch)
         val roots = libraries.map { it.first }
         val out = LinkedHashMap<Int, SteamGame>()
         for ((library, label) in libraries) {
@@ -116,29 +124,38 @@ object Library {
                     val installDir = INSTALL_DIR.find(text)?.groupValues?.get(1)?.trim()
                         ?.takeIf { it.isNotEmpty() && it != "." && it != ".." && '/' !in it && '\\' !in it }
                     val gameFiles = installDir?.let { File(steamapps, "common/$it").takeIf(File::isDirectory) }
-                    out[appId] = SteamGame(
+                    out[appId] = SteamGameArt.withOverrides(context, SteamGame(
                         appId, name, art, label, hero = hero, lastPlayed = lastPlayed,
                         gameFiles = gameFiles,
                         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) },
-                    )
+                    ))
                 }
         }
         return out.values.toList()
     }
 
     fun steamLibraryArt(context: Context): List<Pair<Int, File>> {
-        val cache = File(LinuxRuntime.rootDir(context), "root/.local/share/Steam/appcache/librarycache")
+        val cache = File(SessionPrefs.activeSteamRoot(context), "appcache/librarycache")
         return cache.listFiles().orEmpty().mapNotNull { dir ->
             val appId = dir.name.toIntOrNull()?.takeIf { it !in NOT_GAMES } ?: return@mapNotNull null
             steamCacheImage(cache, appId, STEAM_CAPSULES)?.let { appId to it }
         }
     }
 
-    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 }
+    fun fromSteamClient(g: SteamGame): Boolean = g.library != ADDED && g.source == SOURCE_STEAM
+
+    fun launchableGames(
+        context: Context, strictRead: Boolean = false, added: List<AddedGames.Game>? = null,
+        arch: String = SessionPrefs.activeSteamClientArch(context),
+    ): List<SteamGame> {
+        val roots = steamLibraries(context, arch).map { it.first }
+        val list = added ?: AddedGames.scan(context)
+        var steam = steamGames(context, strictRead, arch)
+        val targets = steam.filter(::fromSteamClient).map { SteamGrid.target(it, context) } + list.map { SteamGrid.target(it, context) }
+        if (runCatching { SteamGrid.sync(context, targets) }.getOrDefault(false)) steam = steamGames(context, strictRead, arch)
+        return (steam + list.map { g -> addedGame(context, g, roots) }).distinctBy { it.gameId }
     }
 
     fun addedGame(context: Context, g: AddedGames.Game, roots: List<File> = steamLibraries(context).map { it.first }): SteamGame =
@@ -152,7 +169,7 @@ object Library {
             )
         }
 
-    private fun steamCacheImage(cache: File, appId: Int, names: List<String>): File? {
+    internal fun steamCacheImage(cache: File, appId: Int, names: List<String>): File? {
         val appDir = File(cache, appId.toString())
         val dirs = listOf(appDir) + appDir.listFiles()
             .orEmpty().filter { it.isDirectory }.sortedBy { it.name }
@@ -185,7 +202,8 @@ object Library {
         if (program == com.droiddeck.launcher.runtime.FlatpakManager.LAUNCHER || program == com.droiddeck.launcher.runtime.AppImageManager.LAUNCHER ||
             program == com.droiddeck.launcher.runtime.UserApps.SCRIPT_LAUNCHER) {
             com.droiddeck.launcher.session.SessionState.programArgs.firstOrNull()?.let { flatpakNames[it] ?: it.substringAfterLast('.') }
-        } else specs.firstOrNull { it.program == program }?.name
+        } else com.droiddeck.launcher.session.NoSteamLaunch.nameFor(program, com.droiddeck.launcher.session.SessionState.programArgs)
+            ?: specs.firstOrNull { it.program == program }?.name
 
     val flatpakNames = java.util.concurrent.ConcurrentHashMap<String, String>()
 

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

@@ -10,10 +10,14 @@ object LibraryCache {
     private const val TAG = "LibraryCache"
     private fun file(context: Context) = File(context.filesDir, "library-cache.json")
 
-    fun load(context: Context): List<Library.SteamGame> = runCatching {
+    /** The cached games and whether they are the x86-64 client's; a cache written as a bare list is arm64's. */
+    @Synchronized
+    fun snapshot(context: Context): Pair<List<Library.SteamGame>, Boolean> = runCatching {
         val f = file(context)
-        if (!f.isFile) return emptyList()
-        val array = JSONArray(f.readText())
+        if (!f.isFile) return Pair(emptyList(), false)
+        val text = f.readText().trim()
+        val (array, x64) = if (text.startsWith("{")) JSONObject(text).let { it.getJSONArray("games") to (it.optString("client") == "x86_64") }
+            else JSONArray(text) to false
         List(array.length()) { i ->
             val o = array.getJSONObject(i)
             Library.SteamGame(
@@ -24,11 +28,18 @@ object LibraryCache {
                 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() }
+        } to x64
+    }.getOrElse { e -> Log.w(TAG, "unreadable, ignored: ${e.message}"); Pair(emptyList(), false) }
 
-    fun save(context: Context, games: List<Library.SteamGame>) {
+    fun load(context: Context): List<Library.SteamGame> = snapshot(context).first
+
+    fun listedX64(context: Context): Boolean = snapshot(context).second
+
+    /** Without [x64] the list keeps the client already recorded. */
+    @Synchronized
+    fun save(context: Context, games: List<Library.SteamGame>, x64: Boolean? = null) {
         runCatching {
+            val client = x64 ?: listedX64(context)
             val array = JSONArray()
             for (g in games) array.put(
                 JSONObject().put("appId", g.appId).put("name", g.name).put("library", g.library).put("gameId", g.gameId)
@@ -38,8 +49,12 @@ object LibraryCache {
             )
             val f = file(context)
             val tmp = File(f.path + ".tmp")
-            tmp.writeText(array.toString())
-            tmp.renameTo(f)
+            tmp.writeText(JSONObject().put("client", if (client) "x86_64" else "arm64").put("games", array).toString())
+            if (!tmp.renameTo(f)) {
+                tmp.delete()
+                f.delete()
+                Log.w(TAG, "not saved: rename failed; cache dropped so the next start scans")
+            }
         }.onFailure { e -> Log.w(TAG, "not saved: ${e.message}") }
     }
 

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

@@ -0,0 +1,48 @@
+package com.droiddeck.launcher.frontend
+
+import org.json.JSONObject
+
+/** Where Steam pins a game's logo on its hero image and how big it draws it; the same JSON Steam keeps in `<appid>.json`. */
+object LogoPosition {
+    enum class Pin(val steam: String) {
+        UPPER_LEFT("UpperLeft"), UPPER_CENTER("UpperCenter"), CENTER("CenterCenter"), BOTTOM_LEFT("BottomLeft"), BOTTOM_CENTER("BottomCenter");
+
+        companion object {
+            fun of(steam: String): Pin? = values().firstOrNull { it.steam == steam }
+        }
+    }
+
+    data class Value(val pin: Pin, val widthPct: Int, val heightPct: Int)
+
+    const val MIN_PCT = 10
+    const val MAX_PCT = 100
+
+    /** What Steam draws when a game has no custom position. */
+    val DEFAULT = Value(Pin.BOTTOM_LEFT, 50, 50)
+
+    private const val VERSION = 1
+    private const val KEY = "logoPosition"
+
+    fun sized(pin: Pin, size: Int): Value = size.coerceIn(MIN_PCT, MAX_PCT).let { Value(pin, it, it) }
+
+    /** `{"nVersion":1,"logoPosition":{...}}`, with whatever else [into] already held kept as it was. */
+    fun toJson(value: Value, into: JSONObject = JSONObject()): JSONObject = into
+        .put("nVersion", VERSION)
+        .put(KEY, JSONObject().put("pinnedPosition", value.pin.steam).put("nWidthPct", value.widthPct).put("nHeightPct", value.heightPct))
+
+    fun parse(text: String): Value? = runCatching { parse(JSONObject(text)) }.getOrNull()
+
+    fun parse(json: JSONObject): Value? {
+        val inner = json.optJSONObject(KEY) ?: return null
+        val pin = Pin.of(inner.optString("pinnedPosition")) ?: return null
+        if (!inner.has("nWidthPct") || !inner.has("nHeightPct")) return null
+        return Value(pin, inner.optInt("nWidthPct").coerceIn(MIN_PCT, MAX_PCT), inner.optInt("nHeightPct").coerceIn(MIN_PCT, MAX_PCT))
+    }
+
+    /** [existing] without the logo position; null when nothing but the version number would be left. */
+    fun without(existing: JSONObject): JSONObject? {
+        existing.remove(KEY)
+        val rest = existing.keys().asSequence().filter { it != "nVersion" }.toList()
+        return if (rest.isEmpty()) null else existing
+    }
+}

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

@@ -25,9 +25,16 @@ object SessionInstalls {
             STATE.find(text)?.groupValues?.get(1)?.toIntOrNull() == 4, file.parentFile!!)
     }.getOrNull()
 
-    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") },
+    internal fun steamappsDirs(context: Context): List<File> = (
+        if (com.droiddeck.launcher.session.SessionPrefs.activeSteamClientArch(context) == "x86_64")
+            listOfNotNull(
+                File(com.droiddeck.launcher.session.SessionPrefs.activeSteamRoot(context), "steamapps"),
+                GameStorage.x64CardLibrary(context)?.let { File(it, "steamapps") },
+            )
+        else listOfNotNull(
+            File(LinuxRuntime.rootDir(context), "root/.local/share/Steam/steamapps"),
+            GameStorage.effective(context)?.let { File(it.path, "steamapps") },
+        )
     ).filter { it.isDirectory }
 
     internal class Watch(private val dirs: () -> List<File>) {

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

@@ -3,7 +3,6 @@ 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
@@ -20,7 +19,7 @@ object SteamAppInfo {
 
     class Info(val name: String, val sharedDepots: List<String>)
 
-    fun appinfoFile(context: Context) = File(LinuxRuntime.rootDir(context), "root/.local/share/Steam/appcache/appinfo.vdf")
+    fun appinfoFile(context: Context) = File(com.droiddeck.launcher.session.SessionPrefs.activeSteamRoot(context), "appcache/appinfo.vdf")
 
     @Synchronized
     fun info(context: Context, appId: Int, appinfo: File = appinfoFile(context)): Info? {

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

@@ -0,0 +1,99 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import com.droiddeck.launcher.stores.SteamLiveShortcuts
+import com.droiddeck.launcher.session.SessionPrefs
+import java.io.File
+
+object SteamGameArt {
+    internal fun dir(context: Context, appId: Int) = File(context.filesDir, "steam-art/$appId")
+
+    private fun sourceFile(context: Context, appId: Int, slot: AddedGameArt.Slot) = File(dir(context, appId), "source-${slot.key}")
+
+    internal fun setSource(context: Context, appId: Int, slot: AddedGameArt.Slot, value: String) {
+        val file = sourceFile(context, appId, slot)
+        if (value.isEmpty()) file.delete() else file.apply { parentFile?.mkdirs() }.writeText(value)
+    }
+
+    fun chosenFile(context: Context, appId: Int, slot: AddedGameArt.Slot): File? = AddedGameArt.chosen(dir(context, appId), slot)
+
+    fun withOverrides(context: Context, game: Library.SteamGame): Library.SteamGame {
+        if (game.library == Library.ADDED || !dir(context, game.appId).isDirectory) return game
+        val cover = chosenFile(context, game.appId, AddedGameArt.Slot.COVER)
+        val hero = chosenFile(context, game.appId, AddedGameArt.Slot.BACKGROUND)
+        val icon = chosenFile(context, game.appId, AddedGameArt.Slot.ICON)
+        if (cover == null && hero == null && icon == null) return game
+        return Library.SteamGame(
+            game.appId, game.name, cover ?: game.art, game.library, game.gameId,
+            hero ?: game.hero, game.lastPlayed, game.gameFiles, game.protonPrefix, icon ?: game.icon, game.source, game.storeId,
+        )
+    }
+
+    fun chosenSource(context: Context, appId: Int, slot: AddedGameArt.Slot): Pair<String, String> {
+        val value = sourceFile(context, appId, slot).takeIf { it.isFile }?.readText()?.trim().orEmpty()
+        return value.substringBefore('|') to value.substringAfter('|', "")
+    }
+
+    fun describe(context: Context, game: Library.SteamGame): List<AddedGameArt.SlotState> {
+        val cache = File(SessionPrefs.activeSteamRoot(context), "appcache/librarycache")
+        val own = withOverrides(context, game)
+        return AddedGameArt.Slot.values().map { slot ->
+            chosenFile(context, game.appId, slot)?.let {
+                return@map AddedGameArt.SlotState(slot, it, chosenSource(context, game.appId, slot).first.ifEmpty { AddedGameArt.FILE }, true)
+            }
+            val auto = when (slot) {
+                AddedGameArt.Slot.COVER -> own.art
+                AddedGameArt.Slot.WIDE -> Library.steamCacheImage(cache, game.appId, listOf("library_header.jpg", "header.jpg"))
+                AddedGameArt.Slot.BACKGROUND -> own.hero
+                AddedGameArt.Slot.ICON -> own.icon
+                AddedGameArt.Slot.LOGO -> Library.steamCacheImage(cache, game.appId, listOf("logo.png"))
+            }
+            AddedGameArt.SlotState(slot, auto, if (auto != null) AddedGameArt.STEAM else AddedGameArt.AUTO, false)
+        }
+    }
+
+    fun choices(context: Context, game: Library.SteamGame, slot: AddedGameArt.Slot): AddedGameArt.Choices {
+        val out = ArrayList<AddedGameArt.Option>()
+        AddedGameArt.steamOption(game.appId.toString(), slot)?.let { out.add(it) }
+        val (found, status) = AddedGameArt.sgdbChoices(context, File(dir(context, game.appId), "sgdb-id"), game.appId, game.name, slot)
+        out.addAll(found)
+        return AddedGameArt.Choices(out, status)
+    }
+
+    fun choose(context: Context, game: Library.SteamGame, slot: AddedGameArt.Slot, option: AddedGameArt.Option): Boolean {
+        return synchronized(SteamGrid.lock) {
+            val folder = dir(context, game.appId)
+            val fresh = AddedGameArt.storeNew(folder, slot, option) ?: return@synchronized false
+            if (!push(context, game, slot, fresh)) {
+                fresh.delete()
+                return@synchronized false
+            }
+            AddedGameArt.dropOlder(folder, slot, fresh)
+            setSource(context, game.appId, slot, option.group + "|" + option.full)
+            true
+        }
+    }
+
+    fun reset(context: Context, game: Library.SteamGame, slot: AddedGameArt.Slot) {
+        synchronized(SteamGrid.lock) {
+            if (!push(context, game, slot, null)) return@synchronized
+            AddedGameArt.chosen(dir(context, game.appId), slot)?.delete()
+            setSource(context, game.appId, slot, "")
+        }
+    }
+
+    fun position(context: Context, game: Library.SteamGame): LogoPosition.Value? = SteamGrid.position(SteamGrid.target(game, context))
+
+    fun setPosition(context: Context, game: Library.SteamGame, value: LogoPosition.Value?): Boolean {
+        if (!SteamGrid.writePosition(context, SteamGrid.target(game, context), value)) return false
+        AddedGamesPublisher.later(context) { SteamLiveShortcuts.setLogoPosition(context, game.appId.toLong(), value) }
+        return true
+    }
+
+    private fun push(context: Context, game: Library.SteamGame, slot: AddedGameArt.Slot, file: File?): Boolean {
+        val type = slot.assetType ?: return true
+        if (!SteamGrid.write(context, SteamGrid.target(game, context), slot, file)) return false
+        AddedGamesPublisher.later(context) { SteamLiveShortcuts.setArt(context, game.appId.toLong(), type, file) }
+        return true
+    }
+}

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

@@ -0,0 +1,209 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import android.util.Log
+import com.droiddeck.launcher.session.SessionPrefs
+import org.json.JSONObject
+import java.io.File
+
+/** Steam keeps a game's custom art in `userdata/<account>/config/grid`; this is where DroidDeck's choices and Steam's meet. */
+object SteamGrid {
+    private const val TAG = "SteamGrid"
+
+    /** Every change to a game's art, here or in a scan, takes this first so two of them never interleave. */
+    internal val lock = Any()
+    private const val MANIFEST = ".droiddeck-art.json"
+    private val SUFFIX = mapOf(AddedGameArt.Slot.COVER to "p", AddedGameArt.Slot.WIDE to "", AddedGameArt.Slot.BACKGROUND to "_hero", AddedGameArt.Slot.LOGO to "_logo")
+    private val EXTS = listOf("png", "jpg", "jpeg", "webp")
+
+    class Target(val artDir: File, val id: Long, val setSource: (AddedGameArt.Slot, String) -> Unit)
+
+    fun target(game: Library.SteamGame, context: Context) = Target(SteamGameArt.dir(context, game.appId), game.appId.toLong()) { slot, value ->
+        SteamGameArt.setSource(context, game.appId, slot, value)
+    }
+
+    fun target(game: AddedGames.Game, context: Context) = Target(AddedGameArt.cacheDir(context, game), game.appId and 0xFFFFFFFFL) { slot, value ->
+        SessionPrefs.setAddedGameArtSource(context, game.folder.path, slot.key, value)
+    }
+
+    internal fun dir(context: Context): File? {
+        return AddedGames.accountConfig(SessionPrefs.activeSteamRoot(context))?.let { File(it, "grid") }
+    }
+
+    private fun files(grid: File, id: Long, slot: AddedGameArt.Slot): List<File> =
+        EXTS.map { File(grid, "$id${SUFFIX[slot]}.$it") }.filter { it.isFile }
+
+    private fun signature(file: File?) = if (file == null) "" else "${file.length()}:${file.lastModified()}"
+
+    /** Each Steam client has its own grid folder, so what was last seen there is kept per client. */
+    private fun sigName(context: Context, key: String) =
+        if (SessionPrefs.activeSteamClientArch(context) == "x86_64") "grid-x86_64-$key" else "grid-$key"
+
+    private fun sigFile(context: Context, target: Target, slot: AddedGameArt.Slot) = File(target.artDir, sigName(context, slot.key))
+
+    private fun recorded(context: Context, target: Target, slot: AddedGameArt.Slot): String? =
+        sigFile(context, target, slot).takeIf { it.isFile }?.readText()
+
+    private fun record(context: Context, target: Target, slot: AddedGameArt.Slot, value: String) {
+        target.artDir.mkdirs()
+        sigFile(context, target, slot).writeText(value)
+    }
+
+    private fun writtenByDroidDeck(grid: File): Set<String> = runCatching {
+        val manifest = JSONObject(File(grid, MANIFEST).readText())
+        manifest.keys().asSequence().filter { name -> File(grid, name).let { it.isFile && it.length() == manifest.optLong(name, -1L) } }.toSet()
+    }.getOrDefault(emptySet())
+
+    /** Puts a choice (or, with null, the lack of one) where Steam reads it, whether or not Steam is running. */
+    fun write(context: Context, target: Target, slot: AddedGameArt.Slot, file: File?): Boolean = synchronized(lock) { place(context, target, slot, file) }
+
+    private fun place(context: Context, target: Target, slot: AddedGameArt.Slot, file: File?): Boolean {
+        val suffix = SUFFIX[slot] ?: return true
+        val grid = dir(context) ?: return true
+        if (file == null) {
+            if (files(grid, target.id, slot).map { it.delete() }.any { !it }) return false
+            record(context, target, slot, "")
+            return true
+        }
+        val ext = file.extension.lowercase().let { if (it == "jpeg") "jpg" else it }
+        if (ext !in EXTS) return false
+        grid.mkdirs()
+        val dst = File(grid, "${target.id}$suffix.$ext")
+        val tmp = File(grid, dst.name + ".tmp")
+        val placed = runCatching { file.copyTo(tmp, overwrite = true); if (tmp.renameTo(dst)) dst else null }.getOrNull()
+        if (placed == null) {
+            tmp.delete()
+            return false
+        }
+        if (files(grid, target.id, slot).filter { it != dst }.map { it.delete() }.any { !it }) return false
+        record(context, target, slot, signature(placed))
+        return true
+    }
+
+    private const val POSITION = "logo-position"
+    private const val POSITION_SIG = "json"
+
+    private fun positionFile(grid: File, id: Long) = File(grid, "$id.json")
+
+    private fun positionIn(file: File): LogoPosition.Value? = file.takeIf { it.isFile }?.let { runCatching { it.readText() }.getOrNull() }?.let(LogoPosition::parse)
+
+    /** The logo position chosen here (or taken over from Steam) for a game; null when Steam's own default applies. */
+    fun position(target: Target): LogoPosition.Value? = positionIn(File(target.artDir, POSITION))
+
+    private fun positionRecorded(context: Context, target: Target): String? =
+        File(target.artDir, sigName(context, POSITION_SIG)).takeIf { it.isFile }?.readText()
+
+    private fun recordPosition(context: Context, target: Target, value: String) {
+        target.artDir.mkdirs()
+        File(target.artDir, sigName(context, POSITION_SIG)).writeText(value)
+    }
+
+    private fun storePosition(target: Target, value: LogoPosition.Value?): Boolean {
+        val file = File(target.artDir, POSITION)
+        if (value == null) return !file.exists() || file.delete()
+        target.artDir.mkdirs()
+        return runCatching { file.writeText(LogoPosition.toJson(value).toString()) }.isSuccess
+    }
+
+    /** Sets (or with null, clears) a game's logo position here and in the client's grid folder, whether or not Steam is running. */
+    fun writePosition(context: Context, target: Target, value: LogoPosition.Value?): Boolean = synchronized(lock) {
+        placePosition(context, target, value) && storePosition(target, value)
+    }
+
+    /** Steam keeps the position in `<id>.json`; anything else that file holds is left as it was. */
+    private fun placePosition(context: Context, target: Target, value: LogoPosition.Value?): Boolean {
+        val grid = dir(context) ?: return true
+        val file = positionFile(grid, target.id)
+        val existing = if (file.isFile) runCatching { JSONObject(file.readText()) }.getOrNull() else null
+        if (file.isFile && existing == null) return value == null
+        val next = if (value == null) existing?.let(LogoPosition::without) else LogoPosition.toJson(value, existing ?: JSONObject())
+        if (next == null) {
+            if (file.isFile && !file.delete()) return false
+            recordPosition(context, target, "")
+            return true
+        }
+        grid.mkdirs()
+        val tmp = File(grid, file.name + ".tmp")
+        val placed = runCatching { tmp.writeText(next.toString()); tmp.renameTo(file) }.getOrDefault(false)
+        if (!placed) {
+            tmp.delete()
+            return false
+        }
+        recordPosition(context, target, signature(file))
+        return true
+    }
+
+    /** A `logoPosition` this version cannot read (a pin it does not know, say) is left alone rather than read as "removed". */
+    private fun hasUnknownPosition(file: File): Boolean {
+        val json = runCatching { JSONObject(file.readText()) }.getOrNull() ?: return false
+        return json.has("logoPosition") && LogoPosition.parse(json) == null
+    }
+
+    private fun reconcilePosition(context: Context, grid: File, target: Target) {
+        val file = positionFile(grid, target.id)
+        if (hasUnknownPosition(file)) return
+        val theirs = positionIn(file)
+        val now = if (theirs != null) signature(file) else ""
+        val before = positionRecorded(context, target)
+        val own = position(target)
+        when {
+            before == null && own != null && theirs == null -> placePosition(context, target, own)
+            before == null || now != before -> {
+                // Recorded only once the local side agrees, so a failed take-over is tried again on the next scan.
+                if (theirs != null) {
+                    if (own == theirs || storePosition(target, theirs)) recordPosition(context, target, now)
+                } else {
+                    if (own == null || storePosition(target, null)) recordPosition(context, target, "")
+                }
+            }
+            own != null && own != theirs -> placePosition(context, target, own)
+        }
+    }
+
+    /** Takes over what changed in Steam since the last look; returns true when a choice was added, replaced or dropped. */
+    fun sync(context: Context, targets: List<Target>): Boolean = synchronized(lock) { reconcile(context, targets) }
+
+    private fun reconcile(context: Context, targets: List<Target>): Boolean {
+        val grid = dir(context) ?: return false
+        val ours = writtenByDroidDeck(grid)
+        var changed = false
+        for (target in targets) for (slot in SUFFIX.keys) {
+            try {
+                val own = AddedGameArt.chosen(target.artDir, slot)
+                val present = files(grid, target.id, slot)
+                val theirs = present.filter { it.name !in ours }.maxByOrNull { it.lastModified() }
+                val now = signature(theirs)
+                val before = recorded(context, target, slot)
+                when {
+                    before == null && own != null && theirs == null -> write(context, target, slot, own)
+                    before == null || now != before -> {
+                        if (theirs != null) {
+                            if (own != null && own.length() == theirs.length() && own.readBytes().contentEquals(theirs.readBytes())) record(context, target, slot, now)
+                            else if (AddedGameArt.store(target.artDir, slot, AddedGameArt.Option(AddedGameArt.STEAM, theirs.path, theirs.path))) {
+                                target.setSource(slot, AddedGameArt.STEAM + "|steam-client")
+                                record(context, target, slot, now)
+                                changed = true
+                            }
+                        } else {
+                            if (own != null && present.isEmpty()) { own.delete(); target.setSource(slot, ""); changed = true }
+                            record(context, target, slot, "")
+                        }
+                    }
+                    own != null && theirs != null && now == before && own.length() != theirs.length() -> write(context, target, slot, own)
+                    own != null && present.isEmpty() -> write(context, target, slot, own)
+                }
+            } catch (e: Exception) {
+                Log.w(TAG, "${target.id} ${slot.key}: ${e.javaClass.simpleName}")
+            }
+        }
+        for (target in targets) {
+            try {
+                reconcilePosition(context, grid, target)
+            } catch (e: Exception) {
+                Log.w(TAG, "${target.id} logo position: ${e.javaClass.simpleName}")
+            }
+        }
+        if (changed) Log.i(TAG, "took over art changed in Steam")
+        return changed
+    }
+}

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

@@ -118,23 +118,42 @@ object SteamGridDb {
             .filter { it.optInt("id") > 0 && it.optString("name").isNotEmpty() }
             .map { Game(it.optInt("id"), it.optString("name"), it.optBoolean("verified")) }
 
-    internal fun path(id: Int, slot: AddedGameArt.Slot, page: Int): String {
-        val base = when (slot) {
+    internal fun path(id: Int, slot: AddedGameArt.Slot): String =
+        when (slot) {
             AddedGameArt.Slot.COVER -> "grids/game/$id?dimensions=600x900&$QUERY"
+            AddedGameArt.Slot.WIDE -> "grids/game/$id?dimensions=460x215,920x430&$QUERY"
             AddedGameArt.Slot.BACKGROUND -> "heroes/game/$id?$QUERY"
             AddedGameArt.Slot.LOGO -> "logos/game/$id?$QUERY"
             AddedGameArt.Slot.ICON -> "icons/game/$id?$QUERY"
         }
-        return if (page > 0) "$base&page=$page" else base
-    }
 
-    fun page(key: String, id: Int, slot: AddedGameArt.Slot, page: Int): List<Pair<String, String>> {
-        val items = json(key, "$API/${path(id, slot, page)}")?.optJSONArray("data") ?: return emptyList()
+    fun page(key: String, id: Int, slot: AddedGameArt.Slot): List<Pair<String, String>> {
+        val items = json(key, "$API/${path(id, slot)}")?.optJSONArray("data") ?: return emptyList()
         return ranked(items, pngOnly = slot == AddedGameArt.Slot.LOGO || slot == AddedGameArt.Slot.ICON)
     }
 
+    private const val PAGE_SIZE = 50
+    private const val MAX_PAGES = 4
+
+    fun all(key: String, id: Int, slot: AddedGameArt.Slot): List<Pair<String, String>> {
+        val raw = JSONArray()
+        for (n in 0 until MAX_PAGES) {
+            val url = "$API/${path(id, slot)}" + if (n > 0) "&page=$n" else ""
+            val data: JSONArray? = try {
+                json(key, url)?.optJSONArray("data")
+            } catch (e: Failed) {
+                if (n == 0) throw e
+                null
+            }
+            val items = data ?: break
+            for (i in 0 until items.length()) raw.put(items.get(i))
+            if (items.length() < PAGE_SIZE) break
+        }
+        return ranked(raw, pngOnly = slot == AddedGameArt.Slot.LOGO || slot == AddedGameArt.Slot.ICON)
+    }
+
     fun images(key: String, id: Int, slot: AddedGameArt.Slot, limit: Int): List<Pair<String, String>> =
-        page(key, id, slot, 0).take(limit)
+        page(key, id, slot).take(limit)
 
     internal fun ranked(items: JSONArray, pngOnly: Boolean): List<Pair<String, String>> =
         (0 until items.length()).map { items.getJSONObject(it) }

app/src/main/java/com/droiddeck/launcher/glasses/CalibrationDistanceCheck.kt

@@ -0,0 +1,24 @@
+package com.droiddeck.launcher.glasses
+
+import android.content.Context
+import com.droiddeck.launcher.R
+import kotlin.math.abs
+
+internal data class CalibrationDistanceResult(val accepted: Boolean, val message: String)
+
+internal object CalibrationDistanceCheck {
+    fun evaluate(context: Context, expected: Float, corners: Int, points: List<SpatialVector>?): CalibrationDistanceResult {
+        require(expected.isFinite() && expected in 0.15f..1.5f)
+        if (corners != 24) return CalibrationDistanceResult(false,
+            context.getString(R.string.spatial_distance_corners, corners))
+        if (points?.size != 24 || points.any { !it.finite() }) return CalibrationDistanceResult(false,
+            context.getString(R.string.spatial_distance_depth))
+        val measured=(points.reduce { a,b -> a+b }*(1f/points.size)).length()
+        if (!measured.isFinite()) return CalibrationDistanceResult(false,context.getString(R.string.spatial_distance_invalid))
+        val accepted=abs(measured-expected)<0.05f
+        return CalibrationDistanceResult(accepted,
+            context.getString(R.string.spatial_distance_result,
+                SpatialMeasurements.validation(measured), SpatialMeasurements.validation(expected),
+                context.getString(if (accepted) R.string.spatial_distance_passed else R.string.spatial_distance_retry)))
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/CalibrationObservationData.kt

@@ -0,0 +1,27 @@
+package com.droiddeck.launcher.glasses
+
+import org.json.JSONObject
+
+internal data class CalibrationObservationData(
+    val objects: List<DoubleArray>, val left: List<DoubleArray>, val right: List<DoubleArray>, val head: SpatialPose,
+) {
+    companion object {
+        fun parse(view: JSONObject): CalibrationObservationData {
+            fun points(name: String, dimensions: Int): List<DoubleArray> {
+                val rows=view.getJSONArray(name)
+                require(rows.length() in 12..24) { "Invalid saved board corner count" }
+                return (0 until rows.length()).map { row ->
+                    val values=rows.getJSONArray(row)
+                    require(values.length()==dimensions)
+                    DoubleArray(dimensions) { values.getDouble(it).also { value -> require(value.isFinite()) } }
+                }
+            }
+            val objects=points("objects",3); val left=points("left",2); val right=points("right",2)
+            require(objects.size==left.size && objects.size==right.size)
+            val pose=view.getJSONArray("head")
+            require(pose.length()==7)
+            val head=SpatialPose.fromSdk(FloatArray(7) { pose.getDouble(it).toFloat() }) ?: error("Invalid saved head pose")
+            return CalibrationObservationData(objects,left,right,head)
+        }
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/GlassesDisplayModes.kt

@@ -0,0 +1,29 @@
+package com.droiddeck.launcher.glasses
+
+data class GlassesResolution(val width: Int, val height: Int) {
+    val key: String get() = "${width}x$height"
+}
+
+enum class GlassesDisplayProfile { TWO_D, THREE_D, VR }
+
+internal object GlassesDisplayModes {
+    fun profile(stereo: Boolean, vr: Boolean): GlassesDisplayProfile = when {
+        vr -> GlassesDisplayProfile.VR
+        stereo -> GlassesDisplayProfile.THREE_D
+        else -> GlassesDisplayProfile.TWO_D
+    }
+
+    fun choice(settings: GlassesSettings, profile: GlassesDisplayProfile): String = when (profile) {
+        GlassesDisplayProfile.TWO_D -> settings.resolution2d
+        GlassesDisplayProfile.THREE_D -> settings.resolution3d
+        GlassesDisplayProfile.VR -> settings.resolutionVr
+    }
+
+    fun selected(settings: GlassesSettings, state: GlassesState,
+        stereo: Boolean = state.sbs, vr: Boolean = state.vrActive): GlassesResolution? {
+        val selected = choice(settings, profile(stereo, vr)).ifEmpty {
+            if (vr) choice(settings, profile(stereo, false)) else ""
+        }
+        return state.resolutions.firstOrNull { it.key == selected }
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/GlassesHardware.kt

@@ -0,0 +1,27 @@
+package com.droiddeck.launcher.glasses
+
+/** Hardware properties; display refresh is selected from Android's advertised modes. */
+interface GlassesModel {
+    val name: String
+    val controllable: Boolean
+    val brightnessMax: Int
+    val volumeMax: Int
+    val diagonalFovDeg: Float
+    val sbs90: Boolean
+    val hasSunblock: Boolean get() = true
+    val resolutions: List<GlassesResolution> get() = emptyList()
+    fun mode(hz: Int, sbs: Boolean, resolution: GlassesResolution?): Int = mode(hz, sbs)
+    fun mode(hz: Int, sbs: Boolean): Int
+    fun modeForStep(step: Int): Int?
+}
+
+/** The command IDs here are the existing glasses controller's internal vocabulary.
+ * Each transport translates them to its own wire protocol; unsupported controls return false.
+ */
+internal interface GlassesLink {
+    val hasImu: Boolean
+    val badFrames: Long get() = 0L
+    val ready: Boolean get() = true
+    fun send(msgId: Int, payload: ByteArray = ByteArray(0)): Boolean
+    fun close()
+}

app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuCapture.kt

@@ -0,0 +1,175 @@
+package com.droiddeck.launcher.glasses
+
+import android.app.Activity
+import android.content.Context
+import android.content.ContextWrapper
+import android.graphics.Color
+import android.graphics.PorterDuff
+import android.graphics.SurfaceTexture
+import android.os.Build
+import android.os.Looper
+import android.view.Choreographer
+import android.view.Surface
+import android.view.View
+import android.view.WindowManager
+import android.view.inspector.WindowInspector
+import kotlin.math.min
+import kotlin.math.roundToInt
+
+class GlassesMenuCapture(private val activity: Activity, private val onSize: (Int, Int) -> Unit,
+                         private val onFailure: (Throwable) -> Unit = {}) : Choreographer.FrameCallback {
+    private var texture: SurfaceTexture? = null
+    private var surface: Surface? = null
+    private var running = false
+    private var framePending = false
+    private var lastFrameNs = Long.MIN_VALUE
+    private var failures = 0
+    private var bufferWidth = 0
+    private var bufferHeight = 0
+    private val basePosition = IntArray(2)
+    private val windowPosition = IntArray(2)
+
+    fun attach(texture: SurfaceTexture, surface: Surface) {
+        checkMainThread()
+        this.texture = texture
+        this.surface = surface
+        bufferWidth = 0
+        bufferHeight = 0
+        failures = 0
+        lastFrameNs = Long.MIN_VALUE
+    }
+
+    fun start() {
+        checkMainThread()
+        if (running || activity.isDestroyed || activity.isFinishing) return
+        running = true
+        failures = 0
+        lastFrameNs = Long.MIN_VALUE
+        schedule()
+    }
+
+    fun stop() {
+        checkMainThread()
+        running = false
+        if (framePending) Choreographer.getInstance().removeFrameCallback(this)
+        framePending = false
+    }
+
+    override fun doFrame(frameTimeNanos: Long) {
+        framePending = false
+        if (!running) return
+        if (activity.isDestroyed || activity.isFinishing) {
+            stop()
+            return
+        }
+        if (lastFrameNs == Long.MIN_VALUE || frameTimeNanos - lastFrameNs >= FRAME_INTERVAL_NS) {
+            lastFrameNs = frameTimeNanos
+            try {
+                capture()
+                failures = 0
+            } catch (error: Exception) {
+                if (++failures >= MAX_FAILURES) {
+                    stop()
+                    onFailure(error)
+                }
+            }
+        }
+        if (running) schedule()
+    }
+
+    private fun schedule() {
+        if (framePending) return
+        framePending = true
+        Choreographer.getInstance().postFrameCallback(this)
+    }
+
+    private fun capture() {
+        val target = surface ?: return
+        val input = texture ?: return
+        val decor = activity.window.decorView
+        if (!decor.isAttachedToWindow || !decor.isShown) return
+        val size = captureSize(decor.width, decor.height) ?: return
+        check(target.isValid)
+        if (bufferWidth != size.first || bufferHeight != size.second) {
+            input.setDefaultBufferSize(size.first, size.second)
+            onSize(size.first, size.second)
+            bufferWidth = size.first
+            bufferHeight = size.second
+        }
+        val candidates = if (Build.VERSION.SDK_INT >= 29) WindowInspector.getGlobalWindowViews() else emptyList()
+        val roots = captureRoots(activity, candidates)
+        val canvas = target.lockHardwareCanvas()
+        val initialSave = canvas.save()
+        try {
+            canvas.drawColor(Color.BLACK, PorterDuff.Mode.SRC)
+            val scale = min(canvas.width.toFloat() / decor.width, canvas.height.toFloat() / decor.height)
+            canvas.translate((canvas.width - decor.width * scale) / 2f, (canvas.height - decor.height * scale) / 2f)
+            canvas.scale(scale, scale)
+            canvas.clipRect(0, 0, decor.width, decor.height)
+            decor.getLocationOnScreen(basePosition)
+            for (root in roots) {
+                val params = root.layoutParams as? WindowManager.LayoutParams
+                if (root !== decor && params != null && params.flags and WindowManager.LayoutParams.FLAG_DIM_BEHIND != 0) {
+                    canvas.drawColor(Color.argb((params.dimAmount.coerceIn(0f, 1f) * 255).roundToInt(), 0, 0, 0))
+                }
+                root.getLocationOnScreen(windowPosition)
+                val saved = canvas.save()
+                try {
+                    canvas.translate((windowPosition[0] - basePosition[0]).toFloat(), (windowPosition[1] - basePosition[1]).toFloat())
+                    root.draw(canvas)
+                } finally {
+                    canvas.restoreToCount(saved)
+                }
+            }
+        } finally {
+            try {
+                canvas.restoreToCount(initialSave)
+            } finally {
+                target.unlockCanvasAndPost(canvas)
+            }
+        }
+    }
+
+    private fun checkMainThread() {
+        check(Looper.myLooper() == Looper.getMainLooper())
+    }
+
+    internal companion object {
+        private const val FRAME_INTERVAL_NS = 33_333_334L
+        private const val MAX_FAILURES = 3
+        private const val MAX_EDGE = 1920
+
+        internal fun captureSize(width: Int, height: Int): Pair<Int, Int>? {
+            if (width <= 0 || height <= 0) return null
+            val scale = min(1.0, MAX_EDGE.toDouble() / maxOf(width, height))
+            return (width * scale).roundToInt().coerceAtLeast(1) to (height * scale).roundToInt().coerceAtLeast(1)
+        }
+
+        internal fun captureRoots(activity: Activity, candidates: List<View>): List<View> {
+            val decor = activity.window.decorView
+            if (activity.window.attributes.flags and WindowManager.LayoutParams.FLAG_SECURE != 0 ||
+                !decor.isAttachedToWindow || !decor.isShown) return emptyList()
+            if (Build.VERSION.SDK_INT < 29) return listOf(decor)
+            val display = decor.display?.displayId ?: return listOf(decor)
+            val token = decor.applicationWindowToken
+            return listOf(decor) + candidates.filter { root ->
+                if (root === decor || !root.isAttachedToWindow || !root.isShown || root.display?.displayId != display) return@filter false
+                val params = root.layoutParams as? WindowManager.LayoutParams ?: return@filter false
+                if (params.flags and WindowManager.LayoutParams.FLAG_SECURE != 0 ||
+                    params.type !in WindowManager.LayoutParams.FIRST_APPLICATION_WINDOW..WindowManager.LayoutParams.LAST_SUB_WINDOW) return@filter false
+                ownsContext(root.context, activity) || (token != null && root.applicationWindowToken == token)
+            }.distinct()
+        }
+
+        private fun ownsContext(context: Context, activity: Activity): Boolean {
+            var current = context
+            repeat(16) {
+                if (current === activity) return true
+                val next = (current as? ContextWrapper)?.baseContext ?: return false
+                if (next === current) return false
+                current = next
+            }
+            return false
+        }
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuMirror.kt

@@ -0,0 +1,219 @@
+package com.droiddeck.launcher.glasses
+
+import android.app.Activity
+import android.app.Application
+import android.app.Presentation
+import android.os.Bundle
+import android.util.Log
+import android.view.Display
+import android.view.WindowManager
+import com.droiddeck.launcher.SessionActivity
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.launch
+
+object GlassesMenuMirror {
+    private var controller: GlassesMenuController? = null
+
+    fun initialize(app: Application) {
+        if (controller != null) return
+        val pose = GlassesMenuPose()
+        val menus = GlassesMenuController(pose,
+            display = Glasses::glassesDisplay,
+            observe = { active -> if (active) Glasses.addPoseObserver(pose) else Glasses.removePoseObserver(pose) },
+            create = { activity, display, failure -> MenuPresentation(activity, display, pose, failure) })
+        controller = menus
+        app.registerActivityLifecycleCallbacks(object : Application.ActivityLifecycleCallbacks {
+            override fun onActivityResumed(activity: Activity) = menus.resume(activity)
+            override fun onActivityPaused(activity: Activity) = menus.pause(activity)
+            override fun onActivityDestroyed(activity: Activity) = menus.pause(activity)
+            override fun onActivityCreated(activity: Activity, state: Bundle?) = Unit
+            override fun onActivityStarted(activity: Activity) = Unit
+            override fun onActivityStopped(activity: Activity) = Unit
+            override fun onActivitySaveInstanceState(activity: Activity, state: Bundle) = Unit
+        })
+        CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate).launch {
+            combine(Glasses.state, Glasses.settings) { state, settings -> state to settings }
+                .collect { (state, settings) -> menus.update(state, settings) }
+        }
+    }
+
+    fun setSessionMenuVisible(activity: Activity, visible: Boolean) {
+        controller?.setSessionMenuVisible(activity, visible)
+    }
+
+    fun recenter() { controller?.recenter() }
+}
+
+internal class GlassesMenuController(
+    private val pose: GlassesMenuPose,
+    private val display: () -> Display?,
+    private val observe: (Boolean) -> Unit,
+    private val create: (Activity, Display, (Throwable) -> Unit) -> Output,
+    private val schedule: (() -> Unit) -> Unit = { android.os.Handler(android.os.Looper.getMainLooper()).post(it) },
+) {
+    interface Output {
+        fun configure(state: GlassesState, settings: GlassesSettings)
+        fun show()
+        fun close()
+    }
+
+    private var activity: Activity? = null
+    private val sessionMenus = java.util.WeakHashMap<Activity, Boolean>()
+    private var state = GlassesState()
+    private var settings = GlassesSettings()
+    private var output: Output? = null
+    private var outputDisplay = Display.INVALID_DISPLAY
+    private var failed = false
+    private var dismissalRetried = false
+    private var generation = 0
+
+    fun resume(owner: Activity) {
+        if (activity !== owner) close()
+        activity = owner
+        failed = false
+        dismissalRetried = false
+        reconcile()
+    }
+
+    fun pause(owner: Activity) {
+        if (activity !== owner) return
+        close()
+        activity = null
+    }
+
+    fun setSessionMenuVisible(owner: Activity, visible: Boolean) {
+        if (visible) sessionMenus[owner] = true else sessionMenus.remove(owner)
+        if (activity === owner) reconcile()
+    }
+
+    fun update(next: GlassesState, preferences: GlassesSettings) {
+        val deviceChanged = state.canControl != next.canControl || state.model != next.model
+        if (deviceChanged) pose.reset()
+        if (deviceChanged || state.displayId != next.displayId || state.width != next.width ||
+            state.height != next.height || state.sbs != next.sbs || settings != preferences) {
+            failed = false
+            dismissalRetried = false
+        }
+        state = next
+        settings = preferences
+        pose.configure(preferences)
+        reconcile()
+    }
+
+    fun recenter() = pose.recenter()
+
+    private fun reconcile() {
+        val owner = activity
+        val eligible = owner != null && !owner.isFinishing && !owner.isDestroyed && !owner.isInPictureInPictureMode &&
+            owner.window.attributes.flags and WindowManager.LayoutParams.FLAG_SECURE == 0 &&
+            owner !is com.droiddeck.launcher.QuestXrActivity &&
+            (owner !is SessionActivity || sessionMenus[owner] == true) &&
+            settings.gameOnGlasses && settings.screen3dof && state.usable && state.canControl && state.supportsScreen3dof
+        val target = if (eligible && !failed) display() else null
+        if (target == null || owner == null || owner.windowManager.defaultDisplay.displayId == target.displayId) {
+            close()
+            return
+        }
+        if (outputDisplay != target.displayId) close()
+        try {
+            output?.let { it.configure(state, settings); return }
+            val token = ++generation
+            val next = create(owner, target) { error ->
+                if (generation == token) {
+                    close()
+                    if (error is GlassesMenuDisplayStopped && !dismissalRetried) {
+                        dismissalRetried = true
+                        val retry = generation
+                        schedule { if (generation == retry && activity === owner) reconcile() }
+                    } else {
+                        Log.w("GlassesMenu", "Tracked menus are unavailable for this display", error)
+                        failed = true
+                    }
+                }
+            }
+            if (generation != token) {
+                next.close()
+                return
+            }
+            output = next
+            outputDisplay = target.displayId
+            next.configure(state, settings)
+            if (generation != token) return
+            observe(true)
+            next.show()
+        } catch (error: RuntimeException) {
+            Log.w("GlassesMenu", "Could not show tracked menus", error)
+            failed = true
+            close()
+        }
+    }
+
+    private fun close() {
+        ++generation
+        val previous = output
+        output = null
+        outputDisplay = Display.INVALID_DISPLAY
+        if (previous != null) {
+            observe(false)
+            try { previous.close() }
+            catch (error: RuntimeException) { Log.w("GlassesMenu", "Could not close tracked menus", error) }
+        }
+    }
+}
+
+internal class GlassesMenuDisplayStopped : IllegalStateException("The glasses menu display stopped")
+
+private class MenuPresentation(
+    private val owner: Activity,
+    display: Display,
+    pose: GlassesMenuPose,
+    private val onFailure: (Throwable) -> Unit,
+) : Presentation(owner, display), GlassesMenuController.Output {
+    private var closed = false
+    private val capture: GlassesMenuCapture = GlassesMenuCapture(owner,
+        onSize = { width, height -> surface.setSourceSize(width, height) }, onFailure = onFailure)
+    private val surface: GlassesMenuSurface = GlassesMenuSurface(context, pose, onFailure = onFailure) { texture, input ->
+        if (!closed) {
+            capture.attach(texture, input)
+            capture.start()
+        }
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        window?.addFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or
+            WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE or WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        setContentView(surface)
+    }
+
+    override fun configure(state: GlassesState, settings: GlassesSettings) {
+        surface.configure(settings, state)
+        val mode = display.mode
+        val hz = if (state.sbs) settings.sbsHz else settings.refreshHz
+        val best = display.supportedModes.filter {
+            it.physicalWidth == mode.physicalWidth && it.physicalHeight == mode.physicalHeight
+        }.minByOrNull { kotlin.math.abs(it.refreshRate - hz) }
+        if (best != null) window?.let { it.attributes = it.attributes.apply { preferredDisplayModeId = best.modeId } }
+    }
+
+    override fun close() {
+        if (closed) return
+        closed = true
+        capture.stop()
+        surface.close()
+        dismiss()
+    }
+
+    override fun onStop() {
+        capture.stop()
+        surface.close()
+        super.onStop()
+        if (!closed) {
+            closed = true
+            onFailure(GlassesMenuDisplayStopped())
+        }
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuPose.kt

@@ -0,0 +1,86 @@
+package com.droiddeck.launcher.glasses
+
+import com.droiddeck.launcher.gpu.HeadPose
+
+class GlassesMenuPose internal constructor(
+    private val spatialEnabled: () -> Boolean = { SpatialTracking.enabled },
+    private val spatialView: (Long) -> SpatialPose? = { now ->
+        synchronized(SpatialTracking.session) {
+            if (SpatialTracking.session.valid(now)) SpatialTracking.session.view(true) else null
+        }
+    },
+    private val recenterSpatial: () -> Unit = { SpatialTracking.recenter(true) },
+) : Glasses.PoseSink {
+    data class Frame(
+        val rotation: FloatArray,
+        val position: FloatArray,
+        val valid: Boolean,
+        val spatial: Boolean,
+    )
+
+    private var tracking = true
+    private var positional = false
+    private var reference: HeadPose.Reference? = null
+    private var latest: FloatArray? = null
+    private var latestTime = 0L
+    private var safe = identity()
+
+    @Synchronized fun configure(settings: GlassesSettings) {
+        if (tracking != settings.headTracking) {
+            reference = null
+            safe = identity()
+        }
+        tracking = settings.headTracking
+        positional = settings.positionalTracking
+    }
+
+    @Synchronized override fun onPose(x: Float, y: Float, z: Float, w: Float, timeNs: Long) {
+        val norm = x*x + y*y + z*z + w*w
+        if (!norm.isFinite() || norm !in 0.25f..2.25f || timeNs <= latestTime) return
+        val matrix = HeadPose.fromGlasses(x, y, z, w)
+        if (matrix.any { !it.isFinite() }) return
+        latest = matrix
+        latestTime = timeNs
+    }
+
+    @Synchronized fun snapshot(now: Long = System.nanoTime()): Frame {
+        if (!tracking) return identity()
+        val spatial = positional && spatialEnabled()
+        if (spatial) {
+            val pose = spatialView(now)
+            val normalized = pose?.rotation?.normalized()
+            if (pose != null && pose.position.finite() && normalized != null) {
+                safe = Frame(normalized.matrix(), pose.position.array(), true, true)
+                return copy(safe)
+            }
+        } else {
+            val matrix = latest
+            if (matrix != null && latestTime > 0 && now-latestTime in 0..MAX_AGE_NS) {
+                val anchor = reference ?: HeadPose.recenter(matrix, centerView = true).also { reference = it }
+                safe = Frame(HeadPose.relative(anchor, matrix), FloatArray(3), true, false)
+                return copy(safe)
+            }
+        }
+        return copy(safe).copy(valid = false, spatial = spatial)
+    }
+
+    @Synchronized fun recenter() {
+        if (positional && spatialEnabled()) recenterSpatial()
+        else reference = null
+    }
+
+    @Synchronized fun reset() {
+        reference = null
+        latest = null
+        latestTime = 0L
+        safe = identity()
+    }
+
+    private fun copy(frame: Frame) = frame.copy(rotation = frame.rotation.copyOf(), position = frame.position.copyOf())
+
+    private fun identity() = Frame(HeadPose.IDENTITY.copyOf(), FloatArray(3), false, false)
+
+    companion object {
+        internal const val MAX_AGE_NS = 100_000_000L
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuSurface.kt

@@ -0,0 +1,291 @@
+package com.droiddeck.launcher.glasses
+
+import android.content.Context
+import android.graphics.SurfaceTexture
+import android.opengl.GLES11Ext
+import android.opengl.GLES20
+import android.opengl.GLSurfaceView
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.Surface
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+import javax.microedition.khronos.egl.EGLConfig
+import javax.microedition.khronos.opengles.GL10
+import kotlin.math.tan
+
+class GlassesMenuSurface(
+    context: Context,
+    private val pose: GlassesMenuPose,
+    private val onFailure: (Throwable) -> Unit = {},
+    private val onInput: (SurfaceTexture, Surface) -> Unit,
+) : GLSurfaceView(context) {
+    private data class Scene(val settings: GlassesSettings, val state: GlassesState)
+
+    private val main = Handler(Looper.getMainLooper())
+    private val closed = AtomicBoolean()
+    private val failed = AtomicBoolean()
+    private val generation = AtomicInteger()
+    private val pendingFrame = AtomicBoolean()
+    private val inputLock = Any()
+    private var inputTexture: SurfaceTexture? = null
+    private var inputSurface: Surface? = null
+    @Volatile private var scene = Scene(GlassesSettings(), GlassesState())
+    @Volatile private var sourceAspect = 16f / 9f
+    private val renderer = MenuRenderer()
+
+    init {
+        setEGLContextClientVersion(2)
+        setEGLConfigChooser(8, 8, 8, 8, 0, 0)
+        preserveEGLContextOnPause = true
+        setRenderer(renderer)
+        renderMode = RENDERMODE_CONTINUOUSLY
+    }
+
+    fun configure(settings: GlassesSettings, state: GlassesState) {
+        pose.configure(settings)
+        scene = Scene(settings, state)
+    }
+
+    fun setSourceSize(width: Int, height: Int) {
+        if (width > 0 && height > 0) sourceAspect = width.toFloat() / height
+    }
+
+    fun close() {
+        if (!closed.compareAndSet(false, true)) return
+        generation.incrementAndGet()
+        queueEvent { renderer.release() }
+    }
+
+    override fun onDetachedFromWindow() {
+        close()
+        super.onDetachedFromWindow()
+        // GLSurfaceView may exit its GL thread before queued cleanup is consumed.
+        releaseInput()
+    }
+
+    private fun releaseInput() = synchronized(inputLock) {
+        inputTexture?.setOnFrameAvailableListener(null)
+        inputSurface?.release()
+        inputTexture?.release()
+        inputSurface = null
+        inputTexture = null
+        pendingFrame.set(false)
+    }
+
+    private fun fail(error: Throwable) {
+        if (!failed.compareAndSet(false, true)) return
+        generation.incrementAndGet()
+        Log.e("GlassesMenu", "Menu rendering is unavailable", error)
+        main.post { if (!closed.get()) onFailure(error) }
+    }
+
+    private inner class MenuRenderer : Renderer {
+        private val vertices = ByteBuffer.allocateDirect(8 * 4).order(ByteOrder.nativeOrder()).asFloatBuffer().apply {
+            put(floatArrayOf(-1f, -1f, 1f, -1f, -1f, 1f, 1f, 1f)); position(0)
+        }
+        private val textureMatrix = FloatArray(16)
+        private var texture = 0
+        private var program = 0
+        private var width = 1
+        private var height = 1
+        private var hasFrame = false
+        private var positionLocation = 0
+        private var textureLocation = 0
+        private var transformLocation = 0
+        private var rotationLocation = IntArray(3)
+        private var headLocation = 0
+        private var screenLocation = 0
+        private var opticsLocation = 0
+
+        override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) {
+            releaseInput()
+            texture = 0
+            program = 0
+            hasFrame = false
+            if (closed.get() || failed.get()) return
+            val token = generation.incrementAndGet()
+            try {
+                program = linkProgram()
+                positionLocation = GLES20.glGetAttribLocation(program, "aPosition")
+                textureLocation = GLES20.glGetUniformLocation(program, "uTexture")
+                transformLocation = GLES20.glGetUniformLocation(program, "uTextureMatrix")
+                rotationLocation = IntArray(3) { GLES20.glGetUniformLocation(program, "uRotation$it") }
+                headLocation = GLES20.glGetUniformLocation(program, "uHead")
+                screenLocation = GLES20.glGetUniformLocation(program, "uScreen")
+                opticsLocation = GLES20.glGetUniformLocation(program, "uOptics")
+                val names = IntArray(1)
+                GLES20.glGenTextures(1, names, 0)
+                texture = names[0]
+                check(texture != 0) { "Could not allocate the menu texture" }
+                GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, texture)
+                GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR)
+                GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR)
+                GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE)
+                GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE)
+                checkGl("initialize menu texture")
+                val incoming = SurfaceTexture(texture)
+                val surface = synchronized(inputLock) {
+                    inputTexture = incoming
+                    Surface(incoming).also { inputSurface = it }
+                }
+                incoming.setOnFrameAvailableListener({
+                    if (!closed.get() && generation.get() == token) pendingFrame.set(true)
+                }, main)
+                main.post {
+                    if (!closed.get() && !failed.get() && generation.get() == token) onInput(incoming, surface)
+                }
+            } catch (e: RuntimeException) {
+                fail(e)
+                release()
+            }
+        }
+
+        override fun onSurfaceChanged(gl: GL10?, width: Int, height: Int) {
+            this.width = width.coerceAtLeast(1)
+            this.height = height.coerceAtLeast(1)
+            GLES20.glViewport(0, 0, this.width, this.height)
+        }
+
+        override fun onDrawFrame(gl: GL10?) {
+            if (closed.get() || failed.get()) return
+            GLES20.glClearColor(0.015f, 0.015f, 0.02f, 1f)
+            GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT)
+            if (program == 0) return
+            if (pendingFrame.getAndSet(false)) synchronized(inputLock) {
+                inputTexture?.let {
+                    try {
+                        it.updateTexImage()
+                        it.getTransformMatrix(textureMatrix)
+                        checkGl("update menu texture")
+                        hasFrame = true
+                    } catch (e: RuntimeException) {
+                        fail(e)
+                        release()
+                        return
+                    }
+                }
+            }
+            if (!hasFrame) return
+            val current = scene
+            val frame = pose.snapshot()
+            val halfWidth = current.settings.screenWidthDm.coerceIn(5, 200) / 20f
+            val distance = current.settings.screenDistanceDm.coerceIn(5, 200) / 10f
+            val mono = !current.state.sbs
+            val fov = current.state.verticalFovDeg.takeIf { it.isFinite() }?.coerceIn(20f, 140f) ?: 23.3f
+            val tangent = tan(Math.toRadians(fov.toDouble()) / 2).toFloat()
+            GLES20.glUseProgram(program)
+            GLES20.glActiveTexture(GLES20.GL_TEXTURE0)
+            GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, texture)
+            GLES20.glUniform1i(textureLocation, 0)
+            GLES20.glUniformMatrix4fv(transformLocation, 1, false, textureMatrix, 0)
+            for (row in 0..2) GLES20.glUniform3fv(rotationLocation[row], 1, frame.rotation, row * 3)
+            GLES20.glUniform3fv(headLocation, 1, frame.position, 0)
+            GLES20.glUniform3f(screenLocation, halfWidth, distance, sourceAspect)
+            GLES20.glUniform4f(opticsLocation, tangent, width.toFloat() / height / (if (mono) 1f else 2f),
+                if (mono) 0f else IPD_METERS / 2f, if (mono) 1f else 0f)
+            vertices.position(0)
+            GLES20.glEnableVertexAttribArray(positionLocation)
+            GLES20.glVertexAttribPointer(positionLocation, 2, GLES20.GL_FLOAT, false, 0, vertices)
+            GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4)
+            GLES20.glDisableVertexAttribArray(positionLocation)
+        }
+
+        fun release() {
+            releaseInput()
+            if (texture != 0) GLES20.glDeleteTextures(1, intArrayOf(texture), 0)
+            if (program != 0) GLES20.glDeleteProgram(program)
+            texture = 0
+            program = 0
+            hasFrame = false
+        }
+
+        private fun checkGl(operation: String) {
+            val error = GLES20.glGetError()
+            check(error == GLES20.GL_NO_ERROR) { "Could not $operation: GL error 0x${error.toString(16)}" }
+        }
+
+        private fun shader(type: Int, source: String): Int {
+            val shader = GLES20.glCreateShader(type)
+            GLES20.glShaderSource(shader, source)
+            GLES20.glCompileShader(shader)
+            val status = IntArray(1)
+            GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, status, 0)
+            if (status[0] == 0) {
+                val error = GLES20.glGetShaderInfoLog(shader)
+                GLES20.glDeleteShader(shader)
+                throw IllegalStateException(error)
+            }
+            return shader
+        }
+
+        private fun linkProgram(): Int {
+            val vertex = shader(GLES20.GL_VERTEX_SHADER, VERTEX)
+            var fragment = 0
+            var linked = 0
+            try {
+                fragment = shader(GLES20.GL_FRAGMENT_SHADER, FRAGMENT)
+                linked = GLES20.glCreateProgram()
+                GLES20.glAttachShader(linked, vertex)
+                GLES20.glAttachShader(linked, fragment)
+                GLES20.glLinkProgram(linked)
+                val status = IntArray(1)
+                GLES20.glGetProgramiv(linked, GLES20.GL_LINK_STATUS, status, 0)
+                check(status[0] != 0) { GLES20.glGetProgramInfoLog(linked) }
+                return linked
+            } catch (e: RuntimeException) {
+                if (linked != 0) GLES20.glDeleteProgram(linked)
+                throw e
+            } finally {
+                GLES20.glDeleteShader(vertex)
+                if (fragment != 0) GLES20.glDeleteShader(fragment)
+            }
+        }
+    }
+
+    companion object {
+        internal const val IPD_METERS = 0.064f
+        private const val VERTEX = """
+            attribute vec2 aPosition;
+            varying vec2 vUv;
+            void main() {
+                gl_Position = vec4(aPosition, 0.0, 1.0);
+                vUv = aPosition * 0.5 + 0.5;
+            }
+        """
+        private const val FRAGMENT = """
+            #extension GL_OES_EGL_image_external : require
+            precision highp float;
+            uniform samplerExternalOES uTexture;
+            uniform mat4 uTextureMatrix;
+            uniform vec3 uRotation0, uRotation1, uRotation2, uHead, uScreen;
+            uniform vec4 uOptics;
+            varying vec2 vUv;
+            vec3 rotate(vec3 v) {
+                return vec3(dot(uRotation0, v), dot(uRotation1, v), dot(uRotation2, v));
+            }
+            void main() {
+                bool mono = uOptics.w > 0.5;
+                float eye = mono || vUv.x < 0.5 ? 0.0 : 1.0;
+                vec2 local = vec2(mono ? vUv.x : vUv.x * 2.0 - eye, 1.0 - vUv.y);
+                vec2 ray = (local - 0.5) * vec2(uOptics.y, 1.0) * (2.0 * uOptics.x);
+                vec3 direction = rotate(vec3(ray.x, -ray.y, -1.0));
+                vec3 origin = uHead + rotate(vec3((eye < 0.5 ? -1.0 : 1.0) * uOptics.z, 0.0, 0.0));
+                vec3 color = vec3(0.015, 0.015, 0.02);
+                if (direction.z < -0.0001) {
+                    float distance = (-uScreen.y - origin.z) / direction.z;
+                    vec3 hit = origin + direction * distance;
+                    vec2 source = vec2(hit.x / uScreen.x, -hit.y * uScreen.z / uScreen.x) * 0.5 + 0.5;
+                    if (distance > 0.0 && all(greaterThanEqual(source, vec2(0.0))) && all(lessThanEqual(source, vec2(1.0)))) {
+                        vec2 uv = (uTextureMatrix * vec4(source.x, 1.0 - source.y, 0.0, 1.0)).xy;
+                        color = texture2D(uTexture, uv).rgb;
+                    }
+                }
+                gl_FragColor = vec4(color, 1.0);
+            }
+        """
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/GlassesModeState.kt

@@ -0,0 +1,84 @@
+package com.droiddeck.launcher.glasses
+
+internal class GlassesModeState(private val timeoutMs: Long) {
+    enum class Confirmation { NONE, WAITING, CONFIRMED, FAILED }
+    data class Device(val productId: Int, val serial: String?)
+
+    private var deadline: Long? = null
+    private var device: Device? = null
+    private var attached = false
+    private var reconnectDeadline: Long? = null
+    private var vrOwned = false
+    var restorePending = false
+        private set
+    val pendingStereo: Boolean get() = deadline != null
+    val nextCheckAt: Long? get() = listOfNotNull(deadline, reconnectDeadline).minOrNull()
+
+    fun updateDevice(current: Device?, now: Long): Boolean {
+        if (reconnectDeadline?.let { now >= it } == true) abandon()
+        if (current == null) {
+            if (attached) reconnectDeadline = now + timeoutMs
+            attached = false
+            return false
+        }
+        val previous = device
+        val changed = previous == null || previous.productId != current.productId ||
+            (previous.serial != null && current.serial != null && previous.serial != current.serial)
+        if (changed) abandon()
+        device = if (!changed && current.serial == null) previous else current
+        attached = true
+        reconnectDeadline = null
+        return changed
+    }
+
+    private fun abandon() {
+        deadline = null
+        reconnectDeadline = null
+        vrOwned = false
+        restorePending = false
+    }
+
+    fun manual() {
+        vrOwned = false
+        restorePending = false
+    }
+
+    fun startVr() {
+        vrOwned = true
+        restorePending = false
+    }
+
+    fun stopVr(): Boolean {
+        if (vrOwned) {
+            vrOwned = false
+            restorePending = true
+        }
+        return restorePending
+    }
+
+    fun sent(stereo: Boolean, now: Long) {
+        deadline = if (stereo) now + timeoutMs else null
+        if (!stereo) restorePending = false
+    }
+
+    fun cancelPending() {
+        deadline = null
+    }
+
+    fun observe(stereo: Boolean, now: Long): Confirmation {
+        val until = deadline ?: return Confirmation.NONE
+        if (stereo) {
+            deadline = null
+            return Confirmation.CONFIRMED
+        }
+        if (now < until) return Confirmation.WAITING
+        if (!attached) {
+            abandon()
+            return Confirmation.NONE
+        }
+        deadline = null
+        vrOwned = false
+        restorePending = true
+        return Confirmation.FAILED
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/GlassesRendering.kt

@@ -0,0 +1,89 @@
+package com.droiddeck.launcher.glasses
+
+import com.droiddeck.launcher.gpu.Cardboard
+
+/** Share the actual picture mode with settings so controls match the rendered view. */
+internal object GlassesRendering {
+    enum class Picture { FLAT, DUPLICATED, VIRTUAL_SCREEN, STEREO }
+
+    fun native30HzAvailable(settings: GlassesSettings, state: GlassesState): Boolean =
+        state.usable && state.supports30Hz && settings.gameOnGlasses
+
+    fun refreshRates(settings: GlassesSettings, state: GlassesState): List<Int> = buildList {
+        if (native30HzAvailable(settings, state)) add(30)
+        add(60)
+        if (!state.sbs || state.sbs90) add(90)
+        if (!state.sbs) add(120)
+    }
+
+    fun outputHz(settings: GlassesSettings, state: GlassesState): Int {
+        val requested = if (state.sbs) settings.sbsHz else settings.refreshHz
+        return when {
+            requested == 30 -> if (native30HzAvailable(settings, state)) 30 else 60
+            state.sbs && !state.sbs90 -> 60
+            else -> requested
+        }
+    }
+
+    fun mirrorRefreshLimit(settings: GlassesSettings, state: GlassesState, outputActive: Boolean): Int {
+        if (!state.usable || outputActive) return 0
+        val hz = outputHz(settings, state)
+        return if (hz == 30 && kotlin.math.abs(state.hz - 30f) >= 0.5f) 60 else hz
+    }
+
+    fun fpsLimit(requested: Int, mirrorRefreshLimit: Int): Int = when {
+        mirrorRefreshLimit <= 0 -> requested
+        requested <= 0 -> mirrorRefreshLimit
+        else -> minOf(requested, mirrorRefreshLimit)
+    }
+
+    fun usesGlasses(state: GlassesState, outputActive: Boolean, steamVrRunning: Boolean): Boolean =
+        outputActive || (steamVrRunning && state.usable)
+
+    fun picture(settings: GlassesSettings, stereoDisplay: Boolean, steamVrRunning: Boolean): Picture =
+        when {
+            steamVrRunning -> Picture.STEREO
+            settings.picture3d == GlassesSettings.PICTURE_SCREEN -> Picture.VIRTUAL_SCREEN
+            settings.picture3d == GlassesSettings.PICTURE_SBS -> Picture.STEREO
+            stereoDisplay -> Picture.DUPLICATED
+            else -> Picture.FLAT
+        }
+
+    fun cardboard(
+        base: Cardboard,
+        settings: GlassesSettings,
+        state: GlassesState,
+        outputActive: Boolean,
+        steamVrRunning: Boolean,
+    ): Cardboard {
+        // Mirror output still uses the glasses' picture and sensors during VR.
+        if (!usesGlasses(state, outputActive, steamVrRunning)) {
+            // SteamVR uses the renderer's enabled flag as headset proximity.
+            // A flat phone preview still needs an active HMD and one SBS eye;
+            // otherwise SteamVR enters standby and leaves a frozen frame.
+            return if (steamVrRunning && !base.enabled) base.copy(
+                enabled = true,
+                source = Cardboard.SOURCE_SBS,
+                viewer = Cardboard.Viewer.NONE.id,
+                mono = true,
+            ) else base
+        }
+        val picture = picture(settings, state.sbs, steamVrRunning)
+        if (picture == Picture.FLAT) return Cardboard.OFF
+        return Cardboard(
+            enabled = true,
+            source = when (picture) {
+                Picture.STEREO -> Cardboard.SOURCE_SBS
+                Picture.DUPLICATED -> Cardboard.SOURCE_FLAT
+                else -> Cardboard.SOURCE_SCREEN
+            },
+            viewer = Cardboard.Viewer.VITURE.id,
+            ipdMm = base.ipdMm,
+            screenWidthDm = settings.screenWidthDm,
+            screenDistanceDm = settings.screenDistanceDm,
+            headTracking = settings.headTracking && state.canControl &&
+                (picture == Picture.VIRTUAL_SCREEN || steamVrRunning),
+            mono = !state.sbs,
+        )
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/GlassesScreen.kt

@@ -0,0 +1,60 @@
+package com.droiddeck.launcher.glasses
+
+import android.app.Presentation
+import android.content.Context
+import android.graphics.Color
+import android.os.Bundle
+import android.util.Log
+import android.view.Display
+import android.view.SurfaceHolder
+import android.view.SurfaceView
+import android.view.ViewGroup
+import android.view.WindowManager
+import android.widget.FrameLayout
+import kotlin.math.abs
+
+class GlassesScreen(context: Context, display: Display, refreshHz: Int, private val callback: SurfaceHolder.Callback, resolution: GlassesResolution? = null) : Presentation(context, display) {
+    val surfaceView = SurfaceView(getContext())
+    internal val trackingRecovery = com.droiddeck.launcher.ui.TrackingRecoveryView(getContext())
+    val holder: SurfaceHolder get() = surfaceView.holder
+    private var wantHz = refreshHz
+    private var wantResolution = resolution
+
+    val hz: Float get() = display.mode.refreshRate
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val root = FrameLayout(context).apply { setBackgroundColor(Color.BLACK) }
+        root.addView(surfaceView, FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+        root.addView(trackingRecovery, FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+        setContentView(root)
+        window?.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        applyMode()
+        surfaceView.holder.addCallback(callback)
+    }
+
+    fun prefer(hz: Int, resolution: GlassesResolution? = null) {
+        wantHz = hz
+        wantResolution = resolution
+        // A 2D/SBS transition can replace the active mode without changing Hz.
+        applyMode()
+    }
+
+    private fun applyMode() {
+        val w = window ?: return
+        val current = display.mode
+        val target = wantResolution
+        val width = target?.width?.times(if (current.physicalWidth >= 3000) 2 else 1) ?: current.physicalWidth
+        val height = target?.height ?: current.physicalHeight
+        val requested = display.supportedModes.filter { it.physicalWidth == width && it.physicalHeight == height }
+        val candidates = requested.ifEmpty { display.supportedModes.filter {
+            it.physicalWidth == current.physicalWidth && it.physicalHeight == current.physicalHeight
+        } }
+        val best = candidates.minByOrNull { abs(it.refreshRate - wantHz) } ?: return
+        if (w.attributes.preferredDisplayModeId != best.modeId) {
+            Log.i("GlassesScreen", "display ${display.displayId}: prefer mode ${best.modeId} " +
+                "${best.physicalWidth}x${best.physicalHeight}@${best.refreshRate} (requested $wantHz Hz)")
+            w.attributes = w.attributes.apply { preferredDisplayModeId = best.modeId }
+        }
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/HandGestures.kt

@@ -0,0 +1,48 @@
+package com.droiddeck.launcher.glasses
+
+import kotlin.math.*
+
+internal class HandGestures(private val rightHand: Boolean) {
+    private var grip = false
+    private var last: SpatialHand? = null
+    var lastOutcome = HandObservationOutcome.LANDMARK_COUNT_INVALID; private set
+    fun reset() { grip = false; last = null }
+    fun resetAfterRejection(outcome: HandObservationOutcome) {
+        if (outcome != HandObservationOutcome.PALM_MOTION_REJECTED) reset()
+    }
+    private fun reject(outcome: HandObservationOutcome): SpatialHand? { lastOutcome = outcome; return null }
+    fun estimate(points: List<SpatialVector?>, worldFromCamera: SpatialPose, time: Long,
+                 leftImage: List<SpatialVector>? = null, rightImage: List<SpatialVector>? = null): SpatialHand? {
+        if (points.size != 21) return reject(HandObservationOutcome.LANDMARK_COUNT_INVALID)
+        val p = points.map { it?.takeIf(SpatialVector::finite) }
+        val wrist = p[0] ?: return reject(HandObservationOutcome.PALM_LANDMARK_MISSING)
+        val index = p[5] ?: return reject(HandObservationOutcome.PALM_LANDMARK_MISSING)
+        val middle = p[9] ?: return reject(HandObservationOutcome.PALM_LANDMARK_MISSING)
+        val ring = p[13] ?: return reject(HandObservationOutcome.PALM_LANDMARK_MISSING)
+        val little = p[17] ?: return reject(HandObservationOutcome.PALM_LANDMARK_MISSING)
+        val width = (index-little).length()
+        if (width !in 0.035f..0.13f) return reject(HandObservationOutcome.PALM_WIDTH_INVALID)
+        val forward = (middle-wrist).normalized() ?: return reject(HandObservationOutcome.PALM_BASIS_INVALID)
+        val lateral = (if (rightHand) little-index else index-little).normalized() ?: return reject(HandObservationOutcome.PALM_BASIS_INVALID)
+        val up = lateral.cross(forward).normalized() ?: return reject(HandObservationOutcome.PALM_BASIS_INVALID)
+        val right = forward.cross(up).normalized() ?: return reject(HandObservationOutcome.PALM_BASIS_INVALID)
+        val palm = (wrist+index+middle+ring+little) * 0.2f
+        val pose = worldFromCamera * SpatialPose(palm,SpatialRotation.fromBasis(right,up,forward * -1f))
+        last?.let { old ->
+            val dt=(time-old.timeNs)/1e9f
+            if (dt>0 && dt<0.2f && (pose.position-old.pose.position).length()>0.08f+dt*3f)
+                return reject(HandObservationOutcome.PALM_MOTION_REJECTED)
+        }
+        val stereo = if (leftImage != null || rightImage != null)
+            StereoFingerGestures.estimate(leftImage,rightImage,grip) else null
+        val triggerValid = stereo?.triggerValid ?: (p[4] != null && p[8] != null)
+        val trigger = stereo?.trigger ?: if (triggerValid) ((0.55f-(p[4]!!-p[8]!!).length()/width)/0.35f).coerceIn(0f,1f) else 0f
+        val gripValid = stereo?.gripValid ?: listOf(12,16,20).all { p[it] != null }
+        val closed = if (stereo == null && gripValid) listOf(12 to 9,16 to 13,20 to 17).count { (tip,base) ->
+            (p[tip]!!-wrist).length() < (p[base]!!-wrist).length()*1.35f
+        } else 0
+        grip=stereo?.grip ?: (gripValid && if(grip) closed>=2 else closed==3)
+        lastOutcome = HandObservationOutcome.ACCEPTED
+        return SpatialHand(pose,time,true,trigger,grip,triggerValid,gripValid).also { last=it }
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/HandImageBuffer.kt

@@ -0,0 +1,57 @@
+package com.droiddeck.launcher.glasses
+
+import android.graphics.Bitmap
+import com.google.mediapipe.framework.image.ByteBufferImageBuilder
+import com.google.mediapipe.framework.image.MPImage
+import java.nio.ByteBuffer
+
+internal class HandImageBuffer {
+    companion object {
+        const val PREPROCESSING = "raw-grayscale-rgb"
+    }
+    private var pixels = ByteBuffer.allocateDirect(0)
+    private var source = IntArray(0)
+    private var rgb = ByteArray(0)
+
+    private fun allocateRgb(count: Int) {
+        if (rgb.size != count * 3) {
+            rgb = ByteArray(count * 3)
+            pixels = ByteBuffer.allocateDirect(rgb.size)
+        }
+    }
+
+    fun image(grayscale: ByteArray, width: Int, height: Int): MPImage {
+        require(width > 0 && height > 0 && width.toLong() * height == grayscale.size.toLong())
+        allocateRgb(grayscale.size)
+        var index = 0
+        for (value in grayscale) {
+            rgb[index++] = value
+            rgb[index++] = value
+            rgb[index++] = value
+        }
+        return image(width, height)
+    }
+
+    fun image(grayscale: Bitmap): MPImage {
+        val count = grayscale.width * grayscale.height
+        if (source.size != count) source = IntArray(count)
+        allocateRgb(count)
+        grayscale.getPixels(source, 0, grayscale.width, 0, 0, grayscale.width, grayscale.height)
+        var index = 0
+        for (pixel in source) {
+            val value = (pixel ushr 16).toByte()
+            rgb[index++] = value
+            rgb[index++] = value
+            rgb[index++] = value
+        }
+        return image(grayscale.width, grayscale.height)
+    }
+
+    private fun image(width: Int, height: Int): MPImage {
+        pixels.clear()
+        pixels.put(rgb)
+        pixels.rewind()
+        // MediaPipe applies the model metadata's float normalization to these RGB bytes.
+        return ByteBufferImageBuilder(pixels, width, height, MPImage.IMAGE_FORMAT_RGB).build()
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/HandInferenceSchedule.kt

@@ -0,0 +1,72 @@
+package com.droiddeck.launcher.glasses
+
+internal class HandInferenceSchedule(
+    private val stableFrames: Int = 3,
+    private val discoveryIntervalMs: Long = 240,
+    private val maximumGapMs: Long = 400
+) {
+    init {
+        require(stableFrames > 0)
+        require(discoveryIntervalMs > 0 && maximumGapMs >= discoveryIntervalMs)
+    }
+
+    private var lastFrameMs = -1L
+    private var selectedAtMs = -1L
+    private var selectedMaximum = 2
+    private var lastSearchMs = -1L
+    private var candidateSide = -1
+    private var consistentFrames = 0
+    private var trackingSide = -1
+
+    fun select(timestampMs: Long): Int {
+        if (timestampMs < 0) {
+            reset()
+            return 2
+        }
+        if (selectedAtMs >= 0 || lastFrameMs >= 0 &&
+            (timestampMs <= lastFrameMs || timestampMs - lastFrameMs > maximumGapMs)) reset()
+        val maximum = if (trackingSide >= 0 && lastSearchMs >= 0 &&
+            timestampMs - lastSearchMs < discoveryIntervalMs) 1 else 2
+        lastFrameMs = timestampMs
+        selectedAtMs = timestampMs
+        selectedMaximum = maximum
+        if (maximum == 2) lastSearchMs = timestampMs
+        return maximum
+    }
+
+    fun observe(timestampMs: Long, leftSides: List<Int>, rightSides: List<Int>,
+                leftRawCount: Int = leftSides.size, rightRawCount: Int = rightSides.size) {
+        if (timestampMs < 0 || selectedAtMs != timestampMs) {
+            reset()
+            return
+        }
+        selectedAtMs = -1L
+        val side = leftSides.singleOrNull() ?: -1
+        val consistent = leftRawCount == 1 && rightRawCount == 1 && side in 0..1 &&
+            rightSides.singleOrNull() == side
+        if (!consistent || selectedMaximum == 1 && side != trackingSide) {
+            forgetHand()
+            return
+        }
+        if (candidateSide != side) {
+            candidateSide = side
+            consistentFrames = 0
+        }
+        consistentFrames = minOf(stableFrames, consistentFrames + 1)
+        if (consistentFrames >= stableFrames) trackingSide = side
+    }
+
+    fun reset() {
+        lastFrameMs = -1L
+        selectedAtMs = -1L
+        selectedMaximum = 2
+        lastSearchMs = -1L
+        forgetHand()
+    }
+
+    private fun forgetHand() {
+        candidateSide = -1
+        consistentFrames = 0
+        trackingSide = -1
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/HandModel.kt

@@ -0,0 +1,10 @@
+package com.droiddeck.launcher.glasses
+
+internal enum class HandModel(val asset: String, val sha256: String) {
+    FULL("models/hand_landmarker.task", "fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1"),
+    LITE("models/hand_landmarker_lite.task", "173c0f47ecee7e935bd4a1e93aa580756b4180c1307c07d709313e82c28672c8");
+
+    companion object {
+        val DEFAULT = FULL
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/HandProcessingRate.kt

@@ -0,0 +1,48 @@
+package com.droiddeck.launcher.glasses
+
+internal class HandProcessingRate {
+    var permille = 500
+        private set
+    private var processingMs = Double.NaN
+    private var headroomSamples = 0
+
+    fun observe(processingNs: Long, observationAgeNs: Long, trackingHealthy: Boolean): Int {
+        if (!trackingHealthy || processingNs <= 0 || observationAgeNs < 0) return reset()
+        val measuredMs = processingNs / 1_000_000.0
+        val ageMs = observationAgeNs / 1_000_000.0
+        processingMs = if (processingMs.isNaN()) measuredMs else processingMs + 0.2 * (measuredMs - processingMs)
+        if (measuredMs >= 80 || ageMs >= 140) {
+            permille = 500
+            headroomSamples = 0
+            return permille
+        }
+        val reduced = when {
+            permille > 500 && processingMs > 1000.0 / 15 -> 500
+            permille == 800 && processingMs > 50 -> 600
+            else -> permille
+        }
+        if (reduced != permille) {
+            permille = reduced
+            headroomSamples = 0
+            return permille
+        }
+        val enoughHeadroom = when (permille) {
+            500 -> processingMs <= 55 && ageMs <= 110
+            600 -> processingMs <= 40 && ageMs <= 90
+            else -> false
+        }
+        headroomSamples = if (enoughHeadroom) headroomSamples + 1 else 0
+        if (headroomSamples >= 8) {
+            permille = if (permille == 500) 600 else 800
+            headroomSamples = 0
+        }
+        return permille
+    }
+
+    fun reset(): Int {
+        permille = 500
+        processingMs = Double.NaN
+        headroomSamples = 0
+        return permille
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/HandTrackingMetrics.kt

@@ -0,0 +1,107 @@
+package com.droiddeck.launcher.glasses
+
+internal enum class HandObservationOutcome {
+    ACCEPTED, DISABLED, CALIBRATION_REQUIRED, CLOCK_NOT_READY, HEAD_TRACKING_INVALID,
+    CAMERA_NOT_SYNCHRONIZED, STALE_OBSERVATION, INFERENCE_UNAVAILABLE,
+    NO_MATCHING_DETECTION, AMBIGUOUS_HANDEDNESS, ONE_CAMERA_ONLY, STEREO_REJECTED,
+    LANDMARK_COUNT_INVALID, PALM_LANDMARK_MISSING, PALM_WIDTH_INVALID, PALM_BASIS_INVALID,
+    PALM_MOTION_REJECTED, WRIST_LANDMARK_MISSING, WRIST_MOTION_REJECTED
+}
+
+internal data class HandObservationDiagnostic(
+    val outcome: HandObservationOutcome,
+    val reconstructedPalmLandmarks: List<Int> = emptyList(),
+    val triggerEstimate: Float = 0f,
+    val triggerGeometryValid: Boolean = false,
+    val gripEstimate: Boolean = false,
+    val gripGeometryValid: Boolean = false,
+    val positionSource: String = "none"
+) {
+    val accepted get() = outcome == HandObservationOutcome.ACCEPTED
+    val triggerValid get() = accepted && triggerGeometryValid
+    val gripValid get() = accepted && gripGeometryValid
+}
+
+internal data class HandSideMetrics(
+    val observations: Long,
+    val accepted: Long,
+    val triggerValid: Long,
+    val gripValid: Long,
+    val triggerAboveClickThreshold: Long,
+    val triggerReleased: Long,
+    val gripPressed: Long,
+    val trackingLosses: Long,
+    val triggerLosses: Long,
+    val gripLosses: Long,
+    val maximumConsecutiveRejected: Long,
+    val outcomes: Map<HandObservationOutcome, Long>
+)
+
+internal data class HandTrackingMetricSnapshot(
+    val processedPairs: Long,
+    val inferencePairs: Long,
+    val left: HandSideMetrics,
+    val right: HandSideMetrics
+)
+
+internal class HandTrackingMetrics {
+    private class Side {
+        val outcomes = LongArray(HandObservationOutcome.entries.size)
+        var triggerValid = 0L
+        var gripValid = 0L
+        var triggerAboveClickThreshold = 0L
+        var triggerReleased = 0L
+        var gripPressed = 0L
+        var trackingLosses = 0L
+        var triggerLosses = 0L
+        var gripLosses = 0L
+        var consecutiveRejected = 0L
+        var maximumConsecutiveRejected = 0L
+        var wasAccepted = false
+        var wasTriggerValid = false
+        var wasGripValid = false
+
+        fun observe(sample: HandObservationDiagnostic) {
+            outcomes[sample.outcome.ordinal]++
+            if (sample.triggerValid) {
+                triggerValid++
+                if (sample.triggerEstimate > 0.65f) triggerAboveClickThreshold++
+                if (sample.triggerEstimate < 0.25f) triggerReleased++
+            }
+            if (sample.gripValid) {
+                gripValid++
+                if (sample.gripEstimate) gripPressed++
+            }
+            if (wasAccepted && !sample.accepted) trackingLosses++
+            if (wasTriggerValid && !sample.triggerValid) triggerLosses++
+            if (wasGripValid && !sample.gripValid) gripLosses++
+            consecutiveRejected = if (sample.accepted) 0 else consecutiveRejected + 1
+            maximumConsecutiveRejected = maxOf(maximumConsecutiveRejected, consecutiveRejected)
+            wasAccepted = sample.accepted
+            wasTriggerValid = sample.triggerValid
+            wasGripValid = sample.gripValid
+        }
+
+        fun snapshot() = HandSideMetrics(outcomes.sum(), outcomes[HandObservationOutcome.ACCEPTED.ordinal],
+            triggerValid, gripValid, triggerAboveClickThreshold, triggerReleased, gripPressed, trackingLosses, triggerLosses, gripLosses,
+            maximumConsecutiveRejected, HandObservationOutcome.entries.filter { outcomes[it.ordinal] > 0 }
+                .associateWith { outcomes[it.ordinal] })
+    }
+
+    private val sides = Array(2) { Side() }
+    private var lastSequence = 0L
+    private var processedPairs = 0L
+    private var inferencePairs = 0L
+
+    fun observe(sequence: Long, inferred: Boolean, left: HandObservationDiagnostic,
+                right: HandObservationDiagnostic) {
+        if (sequence <= lastSequence) return
+        lastSequence = sequence
+        processedPairs++
+        if (inferred) inferencePairs++
+        sides[0].observe(left)
+        sides[1].observe(right)
+    }
+
+    fun snapshot() = HandTrackingMetricSnapshot(processedPairs, inferencePairs, sides[0].snapshot(), sides[1].snapshot())
+}

app/src/main/java/com/droiddeck/launcher/glasses/JoyConFlowGate.kt

@@ -0,0 +1,16 @@
+package com.droiddeck.launcher.glasses
+
+import kotlin.math.hypot
+
+internal object JoyConFlowGate {
+    const val MAX_SEED_AGE_NS = 750_000_000L
+    fun fresh(seed: Long, previous: Long, now: Long) = seed > 0 && previous > 0 &&
+        now > previous && now - previous <= 200_000_000L && now - seed in 0..MAX_SEED_AGE_NS
+
+    fun point(x: Double, y: Double, backX: Double, backY: Double, oldX: Double, oldY: Double,
+              error: Float, forward: Boolean, backward: Boolean, width: Int, height: Int): Boolean =
+        forward && backward && error.isFinite() && error in 0f..20f &&
+            x.isFinite() && y.isFinite() && backX.isFinite() && backY.isFinite() &&
+            x >= 3 && y >= 3 && x < width - 3 && y < height - 3 &&
+            hypot(backX - oldX, backY - oldY) <= 1.5 && hypot(x - oldX, y - oldY) <= 100
+}

app/src/main/java/com/droiddeck/launcher/glasses/JoyConWristPosition.kt

@@ -0,0 +1,26 @@
+package com.droiddeck.launcher.glasses
+
+internal class JoyConWristPosition {
+    private var last: SpatialHand? = null
+    var lastOutcome = HandObservationOutcome.WRIST_LANDMARK_MISSING; private set
+
+    fun reset() { last = null }
+
+    private fun reject(outcome: HandObservationOutcome): SpatialHand? {
+        lastOutcome = outcome
+        return null
+    }
+
+    fun estimate(points: List<SpatialVector?>, worldFromCamera: SpatialPose, time: Long): SpatialHand? {
+        val wrist = points.firstOrNull()?.takeIf(SpatialVector::finite)
+            ?: return reject(HandObservationOutcome.WRIST_LANDMARK_MISSING)
+        val pose = worldFromCamera * SpatialPose(wrist)
+        last?.let { old ->
+            val dt = (time - old.timeNs) / 1e9f
+            if (dt <= 0 || (dt < .2f && (pose.position - old.pose.position).length() > .08f + dt * 3f))
+                return reject(HandObservationOutcome.WRIST_MOTION_REJECTED)
+        }
+        lastOutcome = HandObservationOutcome.ACCEPTED
+        return SpatialHand(pose, time, true, triggerValid = false, gripValid = false).also { last = it }
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/LumaRgbDiagnostic.kt

@@ -0,0 +1,160 @@
+package com.droiddeck.launcher.glasses
+
+import android.Manifest
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.hardware.usb.UsbManager
+import android.os.IBinder
+import android.util.AtomicFile
+import org.json.JSONObject
+import java.io.File
+
+internal object LumaRgbDiagnostic {
+    private fun file(context: Context) = AtomicFile(File(context.filesDir, "spatial/rgb-diagnostic.json"))
+    private fun save(context: Context, value: JSONObject) {
+        val target = file(context)
+        target.baseFile.parentFile?.mkdirs()
+        val output = target.startWrite()
+        try {
+            output.write(value.toString().toByteArray(Charsets.UTF_8))
+            target.finishWrite(output)
+        } catch (e: Exception) { target.failWrite(output); throw e }
+    }
+
+    private fun expired(value: JSONObject, nowMs: Long) = nowMs-value.optLong("startedMs") !in
+        0..value.optLong("timeoutMs",15_000).coerceIn(15_000,45_000)
+
+    private fun workerAlive(context: Context, pid: Int): Boolean = pid > 0 && pid != android.os.Process.myPid() &&
+        runCatching {
+            File("/proc/$pid/cmdline").readText().substringBefore('\u0000') == "${context.packageName}:rgb_diagnostic"
+        }.getOrDefault(false)
+
+    internal fun resolveStatus(value: JSONObject, nowMs: Long, workerAlive: Boolean): JSONObject {
+        val pending = value.optString("state") == "capturing"
+        if (workerAlive && !expired(value,nowMs)) {
+            if (!pending) value.put("resultState",value.optString("state")).put("phase","finishing")
+            return value.put("state","capturing").put("busy",true)
+        }
+        if (pending && (expired(value,nowMs) || value.optInt("workerPid") > 0 && !workerAlive))
+            value.put("state","failed").put("message","RGB capture worker stopped or timed out")
+        return value.put("busy",workerAlive || value.optString("state") == "capturing")
+    }
+
+    fun status(context: Context): JSONObject = runCatching {
+        val value = JSONObject(file(context).readFully().toString(Charsets.UTF_8))
+        val now = android.os.SystemClock.elapsedRealtime()
+        val pid = value.optInt("workerPid")
+        if (expired(value,now) && workerAlive(context,pid)) android.os.Process.killProcess(pid)
+        resolveStatus(value,now,workerAlive(context,pid))
+    }.getOrElse { JSONObject().put("state", "idle") }
+
+    @Synchronized fun capture(context: Context, transport: String = "sdk", width: Int = 640, height: Int = 480,
+                              fps: Int = 30, durationMs: Int = 5000): JSONObject {
+        require(transport in listOf("sdk","uvc") && width in 160..1920 && height in 120..1080 &&
+            fps in 5..30 && durationMs in 1000..30000) { "Invalid RGB capture options" }
+        val app = context.applicationContext
+        val old = status(app)
+        if (old.optBoolean("busy")) return old
+        val usb = app.getSystemService(Context.USB_SERVICE) as UsbManager
+        val device = usb.deviceList.values.singleOrNull { it.vendorId == 0x0c45 && it.productId == 0x636b }
+        fun state(value: String, message: String): JSONObject {
+            val result = JSONObject().put("state", value).put("message", message)
+            save(app, result)
+            return result
+        }
+        if (!Glasses.state.value.spatialConnected || device == null)
+            return state("unavailable", "Connect the Luma Ultra glasses and RGB camera")
+        if (app.checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED)
+            return state("permission_required", "Grant Android camera permission to capture the RGB camera")
+        if (!usb.hasPermission(device)) {
+            val intent = Intent("${app.packageName}.RGB_DIAGNOSTIC_PERMISSION").setPackage(app.packageName)
+            val pending = PendingIntent.getBroadcast(app, 3, intent, PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT)
+            usb.requestPermission(device, pending)
+            return state("permission_required", "Approve the USB camera permission, then request the capture again")
+        }
+        val result = JSONObject().put("state", "capturing").put("startedMs", android.os.SystemClock.elapsedRealtime())
+            .put("timeoutMs",durationMs+15000).put("transport",transport)
+        save(app, result)
+        try { app.startService(Intent(app, LumaRgbCaptureService::class.java).putExtra("device", device.deviceName)
+            .putExtra("transport",transport).putExtra("width",width).putExtra("height",height)
+            .putExtra("fps",fps).putExtra("durationMs",durationMs)) }
+        catch (e: Exception) { return state("failed", e.message ?: e.toString()) }
+        return result
+    }
+
+    internal fun perform(context: Context, deviceName: String, transport: String, width: Int, height: Int,
+                         fps: Int, durationMs: Int) {
+        val folder=File(context.filesDir,"spatial/rgb-captures/${System.nanoTime()}").apply { mkdirs() }
+        val startedMs=android.os.SystemClock.elapsedRealtime()
+        val workerPid=android.os.Process.myPid()
+        save(context,JSONObject().put("state","capturing").put("path",folder.path)
+            .put("startedMs",startedMs).put("timeoutMs",durationMs+15000)
+            .put("transport",transport).put("workerPid",workerPid))
+        val result = try {
+            val direct=transport=="uvc"
+            check(if(direct) UvcRgbDiagnostic.available else VitureSdk.available) { "Requested RGB transport is unavailable" }
+            val usb = context.getSystemService(Context.USB_SERVICE) as UsbManager
+            val device = checkNotNull(usb.deviceList[deviceName]) { "RGB camera disconnected" }
+            check(device.vendorId == 0x0c45 && device.productId == 0x636b && usb.hasPermission(device))
+            val connection = checkNotNull(usb.openDevice(device)) { "Could not open RGB camera" }
+            val metadata=LongArray(if(direct) 14 else 7)
+            val jpeg=try {
+                File(folder,"usb-descriptors.bin").writeBytes(connection.rawDescriptors)
+                android.os.ParcelFileDescriptor.open(File(folder,"usb.log"),
+                    android.os.ParcelFileDescriptor.MODE_CREATE or android.os.ParcelFileDescriptor.MODE_TRUNCATE or
+                        android.os.ParcelFileDescriptor.MODE_WRITE_ONLY).use { log ->
+                    if(direct) UvcRgbDiagnostic.nativeSnapshot(connection.fileDescriptor,width,height,fps,durationMs,metadata,log.fd)
+                    else VitureSdk.nativeRgbSnapshot(device.vendorId,device.productId,connection.fileDescriptor,metadata,log.fd)
+                }
+            } finally { connection.close() }
+            check(jpeg != null) { "RGB camera returned no frame ($transport status ${metadata[4]}, callbacks ${metadata[5]})" }
+            File(folder,"rgb.jpg").writeBytes(jpeg)
+            val info=JSONObject().put("state","completed").put("path",folder.path)
+                .put("width",metadata[0]).put("height",metadata[1]).put("timestampNs",metadata[2])
+                .put("sequence",metadata[3]).put("callbacks",metadata[5]).put("source","Luma Ultra UVC RGB")
+                .put("receiptNs",metadata[6]).put("timingBasis","Host callback receipt; not exposure time")
+                .put("snapshotAcquired",true)
+            if(direct) {
+                val health=UvcStreamHealth.assess(metadata,fps,durationMs)
+                info.put("firstReceiptNs",metadata[7]).put("maxFrameGapMs",health.maximumGapMs)
+                    .put("completeFrames",metadata[9]).put("invalidFrames",metadata[10]).put("bytes",metadata[11])
+                    .put("observationEndNs",metadata[12]).put("tailFrameAgeMs",metadata[13]/1e6)
+                    .put("observationMs",health.observationMs).put("observedFps",health.observedFps)
+                    .put("streamHealthy",health.healthy)
+            }
+            info
+        } catch (e: Exception) { JSONObject().put("state","failed").put("snapshotAcquired",false)
+            .put("message",e.message ?: e.toString()) }
+        result.put("path",folder.path).put("transport",transport).put("requestedWidth",width).put("requestedHeight",height)
+            .put("requestedFps",fps).put("durationMs",durationMs).put("workerPid",workerPid)
+            .put("startedMs",startedMs).put("timeoutMs",durationMs+15000)
+        if (transport == "uvc" && !result.has("streamHealthy")) result.put("streamHealthy",false)
+        File(folder,"frame.json").writeText(result.toString())
+        save(context,result)
+    }
+}
+
+class LumaRgbCaptureService : Service() {
+    private var running = false
+    override fun onBind(intent: Intent?): IBinder? = null
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        if (!running) {
+            running = true
+            Thread({
+                try { LumaRgbDiagnostic.perform(this,intent?.getStringExtra("device") ?: "",
+                    intent?.getStringExtra("transport") ?: "sdk",intent?.getIntExtra("width",640) ?: 640,
+                    intent?.getIntExtra("height",480) ?: 480,intent?.getIntExtra("fps",30) ?: 30,
+                    intent?.getIntExtra("durationMs",5000) ?: 5000) }
+                finally {
+                    stopSelf()
+                    // SDK 2.4.0 can crash while cancelling failed USB transfers; isolate each diagnostic.
+                    android.os.Process.killProcess(android.os.Process.myPid())
+                }
+            }, "luma-rgb-diagnostic").start()
+        }
+        return START_NOT_STICKY
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/RayNeoCalibration.kt

@@ -0,0 +1,105 @@
+package com.droiddeck.launcher.glasses
+
+import android.content.SharedPreferences
+import org.json.JSONArray
+import org.json.JSONObject
+
+enum class CalibrationPhase { IDLE, SETTLING, COLLECTING, MOVING, TURN_OVER, SAVED, FAILED }
+
+data class GlassesCalibrationState(
+    val supported: Boolean = false,
+    val saved: Boolean = false,
+    val phase: CalibrationPhase = CalibrationPhase.IDLE,
+    val progress: Int = 0,
+) {
+    val running: Boolean get() = phase in setOf(CalibrationPhase.SETTLING, CalibrationPhase.COLLECTING,
+        CalibrationPhase.MOVING, CalibrationPhase.TURN_OVER)
+}
+
+internal data class RayNeoCalibration(val gyroBiasDps: Vec3, val level: Quaternion) {
+    fun encode(): String = JSONObject().put("version", 1)
+        .put("bias", JSONArray(listOf(gyroBiasDps.x, gyroBiasDps.y, gyroBiasDps.z)))
+        .put("level", JSONArray(listOf(level.w, level.x, level.y, level.z))).toString()
+
+    companion object {
+        fun decode(json: String?): RayNeoCalibration? = runCatching {
+            val obj = JSONObject(json ?: return null)
+            require(obj.getInt("version") == 1)
+            val b = obj.getJSONArray("bias"); val q = obj.getJSONArray("level")
+            require(b.length() == 3 && q.length() == 4)
+            val bias = Vec3(b.getDouble(0).toFloat(), b.getDouble(1).toFloat(), b.getDouble(2).toFloat())
+            val level = Quaternion(q.getDouble(0).toFloat(), q.getDouble(1).toFloat(), q.getDouble(2).toFloat(), q.getDouble(3).toFloat())
+            require(listOf(bias.x, bias.y, bias.z, level.w, level.x, level.y, level.z).all { it.isFinite() })
+            require(bias.length() <= 6f && level.w in 0.96f..1.001f)
+            val norm = level.w * level.w + level.x * level.x + level.y * level.y + level.z * level.z
+            require(norm in 0.99f..1.01f)
+            RayNeoCalibration(bias, level.normalized())
+        }.getOrNull()
+    }
+}
+
+internal class RayNeoCalibrationStore(private val prefs: SharedPreferences) {
+    companion object {
+        // GT and GT Max can share USB identity fields. Keep the non-Max mounting
+        // correction separate from existing Max profiles and their legacy keys.
+        fun profileKey(base: String, gtUsb: Boolean, boardId: Int): String =
+            if (gtUsb && boardId == RayNeoProtocol.BOARD_GT) "$base:gt-standard-v1" else base
+    }
+    // A serial isolates physical units. Devices without one share their model profile.
+    fun key(vid: Int, pid: Int, serial: String?, modelName: String = ""): String =
+        "rayneo-cal-v1:$vid:$pid:${serial?.takeIf { it.isNotBlank() } ?: "model:$modelName"}"
+    fun load(key: String): RayNeoCalibration? = RayNeoCalibration.decode(prefs.getString(key, null))
+    fun save(key: String, value: RayNeoCalibration?) {
+        if (value == null) prefs.edit().remove(key).apply()
+        else prefs.edit().putString(key, value.encode()).apply()
+    }
+}
+
+/** One upside-down stationary pose estimates gyro bias and tilt, never yaw or accelerometer scale. */
+internal class RayNeoCalibrationCollector(private val axes: RayNeoSensorAxes, private val beganMs: Long) {
+    var phase = CalibrationPhase.SETTLING; private set
+    var progress = 0; private set
+    private var windowStart = -1L
+    private var lastMs = -1L
+    private var count = 0
+    private var meanA = Vec3(0f, 0f, 0f)
+    private var meanG = Vec3(0f, 0f, 0f)
+    private var aVariance = 0f
+    private var gVariance = 0f
+
+    private fun clear(next: CalibrationPhase) {
+        phase = next; progress = 0; windowStart = -1; count = 0
+        meanA = Vec3(0f, 0f, 0f); meanG = meanA; aVariance = 0f; gVariance = 0f
+    }
+
+    fun update(sample: RayNeoSensorSample, nowMs: Long): RayNeoCalibration? {
+        if (phase == CalibrationPhase.FAILED || phase == CalibrationPhase.SAVED) return null
+        if (nowMs - beganMs >= 30_000) { clear(CalibrationPhase.FAILED); return null }
+        val gap = lastMs >= 0 && nowMs - lastMs > 250
+        lastMs = nowMs
+        if (nowMs - beganMs < 3000) return null
+        val a = axes.map(Vec3(sample.accelMps2[0], sample.accelMps2[1], sample.accelMps2[2]))
+        val g = Vec3(sample.gyroDps[0], sample.gyroDps[1], sample.gyroDps[2])
+        if (a.length() !in 8.5f..11f || !g.length().isFinite() || g.length() > 6f || gap) {
+            clear(CalibrationPhase.MOVING); return null
+        }
+        if (a.normalized().y > -0.94f) { clear(CalibrationPhase.TURN_OVER); return null }
+        if (windowStart < 0) windowStart = nowMs
+        phase = CalibrationPhase.COLLECTING
+        count++
+        val da = a - meanA; val dg = g - meanG
+        meanA += da * (1f / count); meanG += dg * (1f / count)
+        fun dot(x: Vec3, y: Vec3) = x.x * y.x + x.y * y.y + x.z * y.z
+        aVariance += dot(da, a - meanA); gVariance += dot(dg, g - meanG)
+        if (count > 25 && (aVariance / count > 0.04f || gVariance / count > 2.25f)) {
+            clear(CalibrationPhase.MOVING); return null
+        }
+        progress = ((nowMs - windowStart) * 100 / 5000).toInt().coerceIn(0, 99)
+        if (nowMs - windowStart < 5000 || count < 200) return null
+        val down = meanA.normalized()
+        val axis = down.cross(Vec3(0f, -1f, 0f))
+        val result = RayNeoCalibration(meanG, Quaternion(1f - down.y, axis.x, axis.y, axis.z).normalized())
+        phase = CalibrationPhase.SAVED; progress = 100
+        return result
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/RayNeoLink.kt

@@ -0,0 +1,202 @@
+package com.droiddeck.launcher.glasses
+
+import android.hardware.usb.UsbDevice
+import android.hardware.usb.UsbDeviceConnection
+import android.hardware.usb.UsbManager
+import android.os.SystemClock
+import android.util.Log
+
+/** RayNeo command/response and IMU share one endpoint. Keep reads on a single worker. */
+internal class RayNeoLink private constructor(
+    private val connection: UsbDeviceConnection,
+    private val endpoints: RayNeoEndpointSelection,
+    private val listener: Listener,
+    private val gt: Boolean,
+    private val loadCalibration: (Int) -> RayNeoCalibration?,
+) : GlassesLink {
+    interface Listener {
+        fun onReady()
+        fun onPose(raw: ByteArray, xyzw: FloatArray, timeNs: Long)
+        fun onLost()
+        fun onCalibration(revision: Long, phase: CalibrationPhase, progress: Int) {}
+        fun onCalibrationSaved(revision: Long, value: RayNeoCalibration?) {}
+        fun onDeviceInfo(boardId: Int, calibrationSaved: Boolean) {}
+    }
+
+    @Volatile private var running = true
+    @Volatile override var ready = false
+        private set
+    @Volatile private var wantImu = false
+    private val writeLock = Any()
+    private val assembler = RayNeoPacketAssembler()
+    private val readBuffer = ByteArray(maxOf(endpoints.inEndpoint.maxPacketSize, 64))
+    private var failures = 0
+    private lateinit var worker: Thread
+    private var calibration: RayNeoCalibration? = null
+    private data class CalibrationCommand(val revision: Long, val action: Int, val saved: RayNeoCalibration? = null)
+    private val calibrationCommand = java.util.concurrent.atomic.AtomicReference<CalibrationCommand?>(null)
+    fun startCalibration(revision: Long) { calibrationCommand.set(CalibrationCommand(revision, 1)) }
+    fun cancelCalibration(revision: Long, saved: RayNeoCalibration?) { calibrationCommand.set(CalibrationCommand(revision, 2, saved)) }
+    fun resetCalibration(revision: Long) { calibrationCommand.set(CalibrationCommand(revision, 3)) }
+    override val hasImu = true
+
+    override fun send(msgId: Int, payload: ByteArray): Boolean {
+        if (!running) return false
+        return when (msgId) {
+            VitureProtocol.MSG_IMU -> {
+                wantImu = payload.firstOrNull() == 1.toByte()
+                true
+            }
+            VitureProtocol.MSG_DISPLAY -> {
+                val mode = payload.firstOrNull()?.toInt()?.and(0xff)
+                ready && (mode == RayNeoProtocol.CMD_SWITCH_TO_3D || mode == RayNeoProtocol.CMD_SWITCH_TO_2D) &&
+                    command(mode)
+            }
+            // No VITURE brightness, volume, film, rate or raw command is sent to RayNeo.
+            else -> false
+        }
+    }
+
+    private fun command(cmd: Int): Boolean = synchronized(writeLock) {
+        if (!running) return false
+        val packet = RayNeoProtocol.buildCommandPacket(cmd, 0, endpoints.outEndpoint.maxPacketSize)
+        connection.bulkTransfer(endpoints.outEndpoint, packet, packet.size, 250) == packet.size
+    }
+
+    private fun read(timeoutMs: Int): ByteArray? {
+        val deadline = SystemClock.elapsedRealtime() + timeoutMs
+        while (running && SystemClock.elapsedRealtime() < deadline) {
+            assembler.nextPacket()?.let { return it }
+            val began = SystemClock.elapsedRealtime()
+            val count = connection.bulkTransfer(endpoints.inEndpoint, readBuffer, readBuffer.size, 50)
+            if (count > 0) {
+                failures = 0
+                assembler.append(readBuffer, count)
+            } else if (count < 0 && SystemClock.elapsedRealtime() - began < 25) {
+                if (++failures >= 50) error("RayNeo USB link lost")
+                SystemClock.sleep(5)
+            }
+        }
+        return null
+    }
+
+    private fun response(cmd: Int, timeoutMs: Int): RayNeoPacket.Response? {
+        val deadline = SystemClock.elapsedRealtime() + timeoutMs
+        while (running && SystemClock.elapsedRealtime() < deadline) {
+            val packet = read(100)?.let(RayNeoProtocol::classifyPacket)
+            if (packet is RayNeoPacket.Response && packet.cmd == cmd) return packet
+        }
+        return null
+    }
+
+    private fun run() {
+        var streaming = false
+        try {
+            check(command(RayNeoProtocol.CMD_ACQUIRE_DEVICE_INFO)) { "RayNeo device-info write failed" }
+            val info = response(RayNeoProtocol.CMD_ACQUIRE_DEVICE_INFO, 2500)
+                ?.let { RayNeoProtocol.parseDeviceInfo(it.raw) } ?: error("RayNeo device-info timed out")
+            val profile = RayNeoSensorProfile.forDevice(gt, info.boardId)
+            val rotation = profile.rotationXDeg
+            val gtMaxAxes = profile.gtMaxAxes
+            calibration = loadCalibration(info.boardId)
+            listener.onDeviceInfo(info.boardId, calibration != null)
+            Log.i("RayNeoLink", "Device board=0x%02x gt=%s".format(info.boardId, gt))
+            var filter = RayNeoOrientationFilter(rotation, gtMaxAxes, calibration)
+            var collector: RayNeoCalibrationCollector? = null
+            var calibrationRevision = 0L
+            var lastCalibrationUpdate = 0L
+            var warmupUntil = 0L
+            var lastSensor = 0L
+            ready = true
+            listener.onReady()
+            while (running) {
+                val request = calibrationCommand.getAndSet(null)
+                if (request != null) calibrationRevision = request.revision
+                when (request?.action) {
+                    1 -> collector = RayNeoCalibrationCollector(RayNeoSensorAxes(rotation, gtMaxAxes), SystemClock.elapsedRealtime())
+                    2 -> {
+                        collector = null
+                        if (calibration != request.saved) {
+                            calibration = request.saved
+                            filter = RayNeoOrientationFilter(rotation, gtMaxAxes, calibration)
+                        }
+                        listener.onCalibration(calibrationRevision, CalibrationPhase.IDLE, 0)
+                    }
+                    3 -> {
+                        collector = null; calibration = null
+                        filter = RayNeoOrientationFilter(rotation, gtMaxAxes)
+                        listener.onCalibrationSaved(calibrationRevision, null)
+                        listener.onCalibration(calibrationRevision, CalibrationPhase.IDLE, 0)
+                    }
+                }
+                if (wantImu != streaming) {
+                    val cmd = if (wantImu) RayNeoProtocol.CMD_OPEN_IMU else RayNeoProtocol.CMD_CLOSE_IMU
+                    check(command(cmd) && response(cmd, 1500) != null) { "RayNeo IMU command timed out" }
+                    streaming = cmd == RayNeoProtocol.CMD_OPEN_IMU
+                    filter = RayNeoOrientationFilter(rotation, gtMaxAxes, calibration)
+                    lastSensor = SystemClock.elapsedRealtime()
+                    warmupUntil = lastSensor + 2000
+                }
+                val raw = read(100)
+                if (streaming && SystemClock.elapsedRealtime() - lastSensor > 4000) error("RayNeo IMU stream stalled")
+                if (raw == null) continue
+                val packet = RayNeoProtocol.classifyPacket(raw)
+                if (streaming && packet is RayNeoPacket.Sensor) {
+                    lastSensor = SystemClock.elapsedRealtime()
+                    collector?.let { c ->
+                        val result = c.update(packet.sample, lastSensor)
+                        if (result != null && calibrationCommand.get() == null) {
+                            calibration = result
+                            filter = RayNeoOrientationFilter(rotation, gtMaxAxes, result)
+                            warmupUntil = lastSensor + 2000
+                            listener.onCalibrationSaved(calibrationRevision, result)
+                        }
+                        if (lastSensor - lastCalibrationUpdate >= 200 || result != null || c.phase == CalibrationPhase.FAILED) {
+                            listener.onCalibration(calibrationRevision, c.phase, c.progress)
+                            lastCalibrationUpdate = lastSensor
+                        }
+                        if (result != null || c.phase == CalibrationPhase.FAILED) collector = null
+                    }
+                    val wxyz = filter.update(packet.sample)
+                    if (wantImu && collector == null && lastSensor >= warmupUntil) {
+                        // Normalize basis and component order at the hardware boundary.
+                        listener.onPose(raw, RayNeoOrientationFilter.glassesPose(wxyz),
+                            SystemClock.elapsedRealtimeNanos())
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            if (running) Log.w("RayNeoLink", "RayNeo stream failed", e)
+        } finally {
+            ready = false
+            if (running) listener.onLost()
+        }
+    }
+
+    override fun close() {
+        synchronized(writeLock) {
+            if (!running) return
+            // Best effort: stop the sensor before releasing the claimed interface.
+            if (ready) runCatching { command(RayNeoProtocol.CMD_CLOSE_IMU) }
+            running = false
+        }
+        if (Thread.currentThread() !== worker) worker.join(500)
+        runCatching { connection.releaseInterface(endpoints.usbInterface) }
+        connection.close()
+    }
+
+    companion object {
+        fun open(usb: UsbManager, device: UsbDevice, listener: Listener, loadCalibration: (Int) -> RayNeoCalibration? = { null }): RayNeoLink? {
+            val endpoints = RayNeoProtocol.selectEndpoints(device) ?: return null
+            val conn = usb.openDevice(device) ?: return null
+            if (!conn.claimInterface(endpoints.usbInterface, true)) {
+                conn.close()
+                return null
+            }
+            return RayNeoLink(conn, endpoints, listener, RayNeoProtocol.isGt(device.vendorId, device.productId), loadCalibration).also { link ->
+                link.worker = Thread({ link.run() }, "rayneo-imu").apply { isDaemon = true }
+                link.worker.start()
+            }
+        }
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/RayNeoModel.kt

@@ -0,0 +1,42 @@
+package com.droiddeck.launcher.glasses
+
+object RayNeoModel {
+    private val modelName = Regex("(?i)(ray\\s*neo|tcl).*\\b(air|gt)(?=\\b|[0-9])")
+
+    fun isVendor(vid: Int) = vid == RayNeoProtocol.VENDOR_ID ||
+        vid == RayNeoProtocol.GT_VENDOR_ID || vid == 0x22d9
+
+    fun model(vid: Int, pid: Int, name: String?): GlassesModel? {
+        if (!isVendor(vid)) return null
+        // GT's identity is confirmed by verncat's SDK; do not claim other products
+        // from that vendor just because their name resembles a supported model.
+        val gt = RayNeoProtocol.isGt(vid, pid)
+        if (vid == RayNeoProtocol.GT_VENDOR_ID && !gt) return null
+        if (!(vid == RayNeoProtocol.VENDOR_ID && pid == RayNeoProtocol.PRODUCT_ID) &&
+            !gt &&
+            !modelName.containsMatchIn(name.orEmpty())) return null
+        return Model(name?.trim()?.takeIf { modelName.containsMatchIn(it) }
+            ?: if (gt) "RayNeo GT series" else "RayNeo Air")
+    }
+
+    fun isDisplay(name: String): Boolean =
+        name.contains("rayneo", ignoreCase = true) || name.contains("ray neo", ignoreCase = true) ||
+            modelName.containsMatchIn(name)
+
+    // Observed on GT Max: Android exposes an unbranded EDID monitor name.
+    // Match its product metadata, not every display called SmartGlasses/TCL.
+    fun isDisplayProduct(name: String?, manufacturer: String?, productId: String?): Boolean =
+        name?.trim().equals("SmartGlasses", ignoreCase = true) &&
+            manufacturer.equals("TCL", ignoreCase = true) && productId == "980"
+
+    private class Model(override val name: String) : GlassesModel {
+        override val controllable = true
+        override val brightnessMax = 0
+        override val volumeMax = 0
+        override val diagonalFovDeg = 46f // Conservative existing default, not a calibrated model profile.
+        override val sbs90 = false
+        override fun mode(hz: Int, sbs: Boolean) =
+            if (sbs) RayNeoProtocol.CMD_SWITCH_TO_3D else RayNeoProtocol.CMD_SWITCH_TO_2D
+        override fun modeForStep(step: Int): Int? = null
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/RayNeoOrientationFilter.kt

@@ -0,0 +1,190 @@
+// Adapted from informalTechCode/RayNeo-Air-Series-3DoF-Scaffold (Apache-2.0).
+// See docs/third-party/rayneo/. Returns scaffold quaternions in (w, x, y, z) order.
+package com.droiddeck.launcher.glasses
+
+import kotlin.math.cos
+import kotlin.math.sin
+import kotlin.math.sqrt
+
+internal data class Vec3(val x: Float, val y: Float, val z: Float) {
+    fun length(): Float = sqrt(x * x + y * y + z * z)
+
+    fun normalized(): Vec3 {
+        val n = length()
+        if (n < 1e-6f) {
+            return Vec3(0f, 0f, 0f)
+        }
+        return Vec3(x / n, y / n, z / n)
+    }
+
+    fun cross(other: Vec3): Vec3 {
+        return Vec3(
+            y * other.z - z * other.y,
+            z * other.x - x * other.z,
+            x * other.y - y * other.x
+        )
+    }
+
+    operator fun plus(other: Vec3): Vec3 = Vec3(x + other.x, y + other.y, z + other.z)
+    operator fun minus(other: Vec3): Vec3 = Vec3(x - other.x, y - other.y, z - other.z)
+    operator fun times(scale: Float): Vec3 = Vec3(x * scale, y * scale, z * scale)
+}
+
+internal data class Quaternion(val w: Float, val x: Float, val y: Float, val z: Float) {
+    operator fun times(other: Quaternion): Quaternion {
+        return Quaternion(
+            w = w * other.w - x * other.x - y * other.y - z * other.z,
+            x = w * other.x + x * other.w + y * other.z - z * other.y,
+            y = w * other.y - x * other.z + y * other.w + z * other.x,
+            z = w * other.z + x * other.y - y * other.x + z * other.w
+        )
+    }
+
+    operator fun times(scale: Float): Quaternion {
+        return Quaternion(w * scale, x * scale, y * scale, z * scale)
+    }
+
+    fun normalized(): Quaternion {
+        val n = sqrt(w * w + x * x + y * y + z * z)
+        if (n < 1e-6f) {
+            return IDENTITY
+        }
+        return Quaternion(w / n, x / n, y / n, z / n)
+    }
+
+    fun conjugate(): Quaternion = Quaternion(w, -x, -y, -z)
+
+    fun rotate(v: Vec3): Vec3 {
+        val qv = Quaternion(0f, v.x, v.y, v.z)
+        val r = this * qv * conjugate()
+        return Vec3(r.x, r.y, r.z)
+    }
+
+    fun integrateBodyRate(omegaRadPerSec: Vec3, dtSec: Float): Quaternion {
+        val omega = Quaternion(0f, omegaRadPerSec.x, omegaRadPerSec.y, omegaRadPerSec.z)
+        val qDot = (this * omega) * 0.5f
+        return Quaternion(
+            w + qDot.w * dtSec,
+            x + qDot.x * dtSec,
+            y + qDot.y * dtSec,
+            z + qDot.z * dtSec
+        )
+    }
+
+    companion object {
+        val IDENTITY = Quaternion(1f, 0f, 0f, 0f)
+
+        fun fromAxisAngle(axis: Vec3, angleRad: Float): Quaternion {
+            val nAxis = axis.normalized()
+            val half = angleRad * 0.5f
+            val s = sin(half)
+            val c = cos(half)
+            return Quaternion(c, nAxis.x * s, nAxis.y * s, nAxis.z * s).normalized()
+        }
+    }
+}
+
+internal data class RayNeoSensorProfile(val rotationXDeg: Float, val gtMaxAxes: Boolean) {
+    companion object {
+        fun forDevice(gtUsb: Boolean, boardId: Int) = when {
+            gtUsb && boardId == RayNeoProtocol.BOARD_GT -> RayNeoSensorProfile(-25f, false)
+            gtUsb -> RayNeoSensorProfile(35f, true)
+            boardId == RayNeoProtocol.BOARD_AIR_4_PRO -> RayNeoSensorProfile(-20f, false)
+            else -> RayNeoSensorProfile(0f, false)
+        }
+    }
+}
+
+internal class RayNeoSensorAxes(imuRotationXDeg: Float, private val gt: Boolean) {
+    private val rotation = Quaternion.fromAxisAngle(Vec3(1f, 0f, 0f),
+        Math.toRadians((if (gt) 35f else imuRotationXDeg).toDouble()).toFloat())
+
+    fun map(v: Vec3): Vec3 = rotation.rotate(if (gt) Vec3(-v.y, v.z, -v.x) else v)
+}
+
+internal class RayNeoOrientationFilter(
+    imuRotationXDeg: Float,
+    gt: Boolean = false,
+    private val calibration: RayNeoCalibration? = null,
+) {
+    private val worldUp = Vec3(0f, 1f, 0f)
+    private val accelGain = 1.5f
+    private val dpsToRad = (Math.PI.toFloat() / 180f)
+    private val gravityMps2 = 9.81f
+    private val stationaryAccelTol = 1.25f
+    private val stationaryGyroRadPerSec = 0.18f
+    private val gyroBiasUpdateHz = 0.5f
+    private val axes = RayNeoSensorAxes(imuRotationXDeg, gt)
+
+    private var q = Quaternion.IDENTITY
+    private var gravityInitialized = false
+    private var gyroBias = Vec3(0f, 0f, 0f)
+    private var lastTick100us: Long = -1L
+    private var lastRealtimeNs: Long = 0L
+
+    companion object {
+        /** Scaffold: right +X, up +Y, back +Z. VITURE: right -Y, up +Z, back -X.
+         * Conjugate by HeadPose.GLASSES_AXES before entering the unchanged VITURE pose path.
+         * This is a basis conversion, not a projection or seated-origin adjustment.
+         */
+        fun glassesPose(wxyz: FloatArray): FloatArray =
+            floatArrayOf(-wxyz[3], -wxyz[1], wxyz[2], wxyz[0])
+    }
+
+    fun update(sample: RayNeoSensorSample): FloatArray {
+        var accel = Vec3(sample.accelMps2[0], sample.accelMps2[1], sample.accelMps2[2])
+        var gyro = Vec3(sample.gyroDps[0], sample.gyroDps[1], sample.gyroDps[2])
+        calibration?.let { gyro -= it.gyroBiasDps }
+        accel = axes.map(accel)
+        gyro = axes.map(gyro) * dpsToRad
+        calibration?.let {
+            accel = it.level.rotate(accel)
+            gyro = it.level.rotate(gyro)
+        }
+
+        val nowNs = System.nanoTime()
+        var dtSec = 0.01f
+        if (lastTick100us >= 0L && sample.deviceTick100us != lastTick100us) {
+            dtSec = (((sample.deviceTick100us - lastTick100us) and 0xffffffffL).toFloat() * 1e-4f)
+        } else if (lastRealtimeNs > 0L && nowNs > lastRealtimeNs) {
+            dtSec = ((nowNs - lastRealtimeNs).toFloat() * 1e-9f)
+        }
+        if (dtSec < 0.001f || dtSec > 0.1f) {
+            dtSec = 0.01f
+        }
+        lastTick100us = sample.deviceTick100us
+        lastRealtimeNs = nowNs
+
+        val accelNorm = accel.length()
+        val stationary =
+            kotlin.math.abs(accelNorm - gravityMps2) < stationaryAccelTol &&
+                gyro.length() < stationaryGyroRadPerSec
+        if (stationary) {
+            val alpha = minOf(1f, dtSec * gyroBiasUpdateHz)
+            gyroBias = gyroBias * (1f - alpha) + gyro * alpha
+        }
+        gyro -= gyroBias
+
+        if (accelNorm > 1e-3f) {
+            val measuredUp = accel.normalized()
+            if (!gravityInitialized) {
+                // Align gravity before publishing the first pose. Starting at
+                // identity and settling after recenter can rotate the horizon.
+                val axis = measuredUp.cross(worldUp)
+                q = if (measuredUp.y < -0.9999f) {
+                    Quaternion.fromAxisAngle(Vec3(1f, 0f, 0f), Math.PI.toFloat())
+                } else {
+                    Quaternion(1f + measuredUp.y, axis.x, axis.y, axis.z).normalized()
+                }
+                gravityInitialized = true
+            }
+            val predictedUp = q.conjugate().rotate(worldUp).normalized()
+            // q maps body to world: measured x predicted reduces gravity error.
+            val correction = measuredUp.cross(predictedUp)
+            gyro += correction * accelGain
+        }
+
+        q = q.integrateBodyRate(gyro, dtSec).normalized()
+        return floatArrayOf(q.w, q.x, q.y, q.z)
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/RayNeoProtocol.kt

@@ -0,0 +1,270 @@
+// Adapted from informalTechCode/RayNeo-Air-Series-3DoF-Scaffold (Apache-2.0).
+// See docs/third-party/rayneo/ for license and protocol attribution.
+package com.droiddeck.launcher.glasses
+
+import android.hardware.usb.UsbConstants
+import android.hardware.usb.UsbDevice
+import android.hardware.usb.UsbEndpoint
+import android.hardware.usb.UsbInterface
+import java.util.Arrays
+
+private fun Byte.u(): Int = toInt() and 0xFF
+
+data class RayNeoSensorSample(
+    val accelMps2: FloatArray,
+    val gyroDps: FloatArray,
+    val temperatureC: Float,
+    val magnet: FloatArray,
+    val proximity: Float,
+    val light: Float,
+    val deviceTick100us: Long
+)
+
+data class RayNeoDeviceInfo(
+    val boardId: Int,
+    val sideBySideEnabled: Boolean
+)
+
+sealed interface RayNeoPacket {
+    data class Sensor(val sample: RayNeoSensorSample) : RayNeoPacket
+    data class Response(val cmd: Int, val raw: ByteArray) : RayNeoPacket
+    data object Unknown : RayNeoPacket
+}
+
+data class RayNeoEndpointSelection(
+    val usbInterface: UsbInterface,
+    val inEndpoint: UsbEndpoint,
+    val outEndpoint: UsbEndpoint
+)
+
+object RayNeoProtocol {
+    const val VENDOR_ID = 0x1BBB
+    const val PRODUCT_ID = 0xAF50
+    // verncat/RayNeo-Air-3S-Pro-OpenVR PR #3 (MIT), tested on GT hardware.
+    const val GT_VENDOR_ID = 0x3941
+    private const val GT_CONTROL_INTERFACE = 5
+
+    fun isGt(vid: Int, pid: Int) = vid == GT_VENDOR_ID && pid == PRODUCT_ID
+
+    const val BOARD_AIR_4_PRO = 0x3A
+    const val BOARD_GT = 0x40 // Observed on the user's non-Max GT.
+
+    const val PKT_MAGIC = 0x99
+    const val PKT_SENSOR = 0x65
+    const val PKT_RESPONSE = 0xC8
+
+    const val CMD_ACQUIRE_DEVICE_INFO = 0
+    const val CMD_OPEN_IMU = 1
+    const val CMD_CLOSE_IMU = 2
+    const val CMD_SWITCH_TO_3D = 6
+    const val CMD_SWITCH_TO_2D = 7
+
+    private const val RESPONSE_CMD_OFFSET = 8
+
+    private const val ACCEL_OFFSET = 4
+    private const val GYRO_OFFSET = 16
+    private const val TEMP_OFFSET = 28
+    private const val MAG_X_OFFSET = 32
+    private const val TICK_OFFSET = 40
+    private const val PSENSOR_OFFSET = 44
+    private const val LSENSOR_OFFSET = 48
+    private const val MAG_Z_OFFSET = 52
+
+    private const val DEVINFO_BOARD_ID_OFFSET = 21
+    private const val DEVINFO_SIDE_BY_SIDE_OFFSET = 43
+
+    fun buildCommandPacket(cmd: Int, arg: Int, packetSize: Int): ByteArray {
+        val len = maxOf(packetSize, 64)
+        val pkt = ByteArray(len)
+        pkt[0] = 0x66
+        pkt[1] = cmd.toByte()
+        pkt[2] = arg.toByte()
+        return pkt
+    }
+
+    fun classifyPacket(raw: ByteArray): RayNeoPacket {
+        if (raw.size < 4 || raw[0].u() != PKT_MAGIC || raw[2].u() != raw.size) {
+            return RayNeoPacket.Unknown
+        }
+
+        return when (raw[1].u()) {
+            PKT_SENSOR -> {
+                val sample = parseSensorSample(raw)
+                if (sample != null) RayNeoPacket.Sensor(sample) else RayNeoPacket.Unknown
+            }
+            PKT_RESPONSE -> {
+                if (raw.size <= RESPONSE_CMD_OFFSET) {
+                    RayNeoPacket.Unknown
+                } else {
+                    RayNeoPacket.Response(raw[RESPONSE_CMD_OFFSET].u(), raw)
+                }
+            }
+            else -> RayNeoPacket.Unknown
+        }
+    }
+
+    fun parseDeviceInfo(raw: ByteArray): RayNeoDeviceInfo? {
+        if (raw.size <= DEVINFO_SIDE_BY_SIDE_OFFSET || raw[2].u() != raw.size || raw[0].u() != PKT_MAGIC ||
+            raw[1].u() != PKT_RESPONSE || raw[RESPONSE_CMD_OFFSET].u() != CMD_ACQUIRE_DEVICE_INFO) {
+            return null
+        }
+
+        return RayNeoDeviceInfo(
+            boardId = raw[DEVINFO_BOARD_ID_OFFSET].u(),
+            sideBySideEnabled = raw[DEVINFO_SIDE_BY_SIDE_OFFSET].u() != 0
+        )
+    }
+
+    fun selectEndpoints(device: UsbDevice): RayNeoEndpointSelection? {
+        val gt = isGt(device.vendorId, device.productId)
+        val gtCandidates = mutableListOf<RayNeoEndpointSelection>()
+        var fallback: RayNeoEndpointSelection? = null
+
+        for (i in 0 until device.interfaceCount) {
+            val usbInterface = device.getInterface(i)
+            var inEndpoint: UsbEndpoint? = null
+            var outEndpoint: UsbEndpoint? = null
+
+            for (j in 0 until usbInterface.endpointCount) {
+                val endpoint = usbInterface.getEndpoint(j)
+                if (endpoint.type != UsbConstants.USB_ENDPOINT_XFER_INT &&
+                    endpoint.type != UsbConstants.USB_ENDPOINT_XFER_BULK) {
+                    continue
+                }
+                // Exclude small button reports from GT's protocol transport.
+                if (gt && endpoint.maxPacketSize < 64) continue
+
+                if (endpoint.direction == UsbConstants.USB_DIR_IN && inEndpoint == null) {
+                    inEndpoint = endpoint
+                } else if (endpoint.direction == UsbConstants.USB_DIR_OUT && outEndpoint == null) {
+                    outEndpoint = endpoint
+                }
+            }
+
+            if (inEndpoint != null && outEndpoint != null) {
+                val selection = RayNeoEndpointSelection(usbInterface, inEndpoint, outEndpoint)
+                if (gt) {
+                    if (usbInterface.id == GT_CONTROL_INTERFACE) return selection
+                    gtCandidates += selection
+                    continue
+                }
+                if (inEndpoint.type == UsbConstants.USB_ENDPOINT_XFER_INT &&
+                    outEndpoint.type == UsbConstants.USB_ENDPOINT_XFER_INT
+                ) {
+                    return selection
+                }
+                if (fallback == null) {
+                    fallback = selection
+                }
+            }
+        }
+
+        // Interface numbers can change with firmware. Use a unique protocol-sized
+        // pair when interface 5 is absent, never an arbitrary composite interface.
+        return if (gt) gtCandidates.singleOrNull() else fallback
+    }
+
+    private fun parseSensorSample(raw: ByteArray): RayNeoSensorSample? {
+        if (raw.size < MAG_Z_OFFSET + 4 ||
+            (ACCEL_OFFSET until TEMP_OFFSET step 4).any { !readF32LE(raw, it).isFinite() }) {
+            return null
+        }
+
+        return RayNeoSensorSample(
+            accelMps2 = floatArrayOf(
+                readF32LE(raw, ACCEL_OFFSET + 0),
+                readF32LE(raw, ACCEL_OFFSET + 4),
+                readF32LE(raw, ACCEL_OFFSET + 8)
+            ),
+            gyroDps = floatArrayOf(
+                readF32LE(raw, GYRO_OFFSET + 0),
+                readF32LE(raw, GYRO_OFFSET + 4),
+                readF32LE(raw, GYRO_OFFSET + 8)
+            ),
+            temperatureC = readF32LE(raw, TEMP_OFFSET),
+            magnet = floatArrayOf(
+                readF32LE(raw, MAG_X_OFFSET),
+                readF32LE(raw, MAG_X_OFFSET + 4),
+                readF32LE(raw, MAG_Z_OFFSET)
+            ),
+            proximity = readF32LE(raw, PSENSOR_OFFSET),
+            light = readF32LE(raw, LSENSOR_OFFSET),
+            deviceTick100us = readU32LE(raw, TICK_OFFSET).toLong() and 0xffffffffL
+        )
+    }
+
+    private fun readU32LE(raw: ByteArray, offset: Int): Int {
+        val b0 = raw[offset].u()
+        val b1 = raw[offset + 1].u()
+        val b2 = raw[offset + 2].u()
+        val b3 = raw[offset + 3].u()
+        return b0 or (b1 shl 8) or (b2 shl 16) or (b3 shl 24)
+    }
+
+    private fun readF32LE(raw: ByteArray, offset: Int): Float {
+        return Float.fromBits(readU32LE(raw, offset))
+    }
+}
+
+class RayNeoPacketAssembler {
+    private val stash = ByteArray(4096)
+    private var len = 0
+
+    fun append(data: ByteArray, count: Int) {
+        require(count in 0..data.size)
+        if (count <= 0) {
+            return
+        }
+
+        if (count >= stash.size || len + count > stash.size) {
+            len = 0
+        }
+
+        val copyLen = minOf(count, stash.size - len)
+        System.arraycopy(data, 0, stash, len, copyLen)
+        len += copyLen
+    }
+
+    fun nextPacket(): ByteArray? {
+        var offset = 0
+        while (offset + 4 <= len) {
+            if (stash[offset].u() != RayNeoProtocol.PKT_MAGIC) {
+                offset++
+                continue
+            }
+
+            val packetLen = stash[offset + 2].u()
+            if (packetLen < 4 || packetLen > 64 ||
+                stash[offset + 1].u() !in listOf(RayNeoProtocol.PKT_SENSOR, RayNeoProtocol.PKT_RESPONSE)) {
+                offset++
+                continue
+            }
+            if (offset + packetLen > len) {
+                break
+            }
+
+            val packet = Arrays.copyOfRange(stash, offset, offset + packetLen)
+            compact(offset + packetLen)
+            return packet
+        }
+
+        if (offset > 0) {
+            compact(offset)
+        }
+        return null
+    }
+
+    private fun compact(consumed: Int) {
+        if (consumed <= 0) {
+            return
+        }
+
+        if (consumed >= len) {
+            len = 0
+            return
+        }
+
+        System.arraycopy(stash, consumed, stash, 0, len - consumed)
+        len -= consumed
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/SpatialMeasurements.kt

@@ -0,0 +1,36 @@
+package com.droiddeck.launcher.glasses
+
+import com.droiddeck.launcher.R
+import java.util.Locale
+import kotlin.math.roundToInt
+
+internal object SpatialMeasurements {
+    fun height(centimeters: Int): String {
+        val tenths = (centimeters / 2.54 * 10).roundToInt()
+        return String.format(Locale.getDefault(), "%d cm (%d ft %.1f in)", centimeters, tenths / 120, tenths % 120 / 10.0)
+    }
+
+    fun distance(meters: Float): String = String.format(
+        Locale.getDefault(), "%.1f m (%.1f ft)", meters, meters / 0.3048f)
+
+    fun validation(meters: Float): String = String.format(
+        Locale.getDefault(), "%.1f cm (%.2f in)", meters * 100, meters / 0.0254f)
+}
+
+internal enum class CalibrationDistance(val meters: Float, val labelRes: Int) {
+    INCHES_12(0.3048f, R.string.spatial_distance_12in),
+    CENTIMETERS_30(0.3f, R.string.spatial_distance_30cm),
+    INCHES_20(0.508f, R.string.spatial_distance_20in),
+    CENTIMETERS_50(0.5f, R.string.spatial_distance_50cm),
+}
+
+internal data class SpatialCalibrationProgress(
+    val collecting: Boolean = false,
+    val views: Int = 0,
+    val fitted: Boolean = false,
+    val solving: Boolean = false,
+    val capturing: Boolean = false,
+    val captureMessage: String? = null,
+    val validating: Boolean = false,
+    val validationMessage: String? = null,
+)

app/src/main/java/com/droiddeck/launcher/glasses/SpatialPose.kt

@@ -0,0 +1,278 @@
+package com.droiddeck.launcher.glasses
+
+import kotlin.math.*
+
+data class SpatialVector(val x: Float = 0f, val y: Float = 0f, val z: Float = 0f) {
+    operator fun plus(b: SpatialVector) = SpatialVector(x + b.x, y + b.y, z + b.z)
+    operator fun minus(b: SpatialVector) = SpatialVector(x - b.x, y - b.y, z - b.z)
+    operator fun times(s: Float) = SpatialVector(x * s, y * s, z * s)
+    fun dot(b: SpatialVector) = x * b.x + y * b.y + z * b.z
+    fun cross(b: SpatialVector) = SpatialVector(y * b.z - z * b.y, z * b.x - x * b.z, x * b.y - y * b.x)
+    fun length() = sqrt(dot(this))
+    fun normalized() = length().takeIf { it > 1e-6f }?.let { this * (1f / it) }
+    fun finite() = x.isFinite() && y.isFinite() && z.isFinite()
+    fun array() = floatArrayOf(x, y, z)
+}
+
+data class SpatialRotation(val x: Float = 0f, val y: Float = 0f, val z: Float = 0f, val w: Float = 1f) {
+    fun normalized(): SpatialRotation? {
+        val n = sqrt(x*x + y*y + z*z + w*w)
+        return if (n.isFinite() && n in 0.5f..1.5f) SpatialRotation(x/n, y/n, z/n, w/n) else null
+    }
+    fun inverse() = SpatialRotation(-x, -y, -z, w)
+    operator fun times(b: SpatialRotation) = SpatialRotation(
+        w*b.x + x*b.w + y*b.z - z*b.y, w*b.y - x*b.z + y*b.w + z*b.x,
+        w*b.z + x*b.y - y*b.x + z*b.w, w*b.w - x*b.x - y*b.y - z*b.z)
+    fun apply(v: SpatialVector): SpatialVector {
+        val q = SpatialVector(x, y, z)
+        val t = q.cross(v) * 2f
+        return v + t * w + q.cross(t)
+    }
+    fun matrix() = floatArrayOf(
+        1-2*(y*y+z*z), 2*(x*y-z*w), 2*(x*z+y*w),
+        2*(x*y+z*w), 1-2*(x*x+z*z), 2*(y*z-x*w),
+        2*(x*z-y*w), 2*(y*z+x*w), 1-2*(x*x+y*y))
+    fun yaw(): SpatialRotation {
+        val forward = apply(SpatialVector(0f, 0f, -1f))
+        val a = if (forward.x*forward.x + forward.z*forward.z < 1e-8f) {
+            val right = apply(SpatialVector(x = 1f))
+            atan2(-right.z, right.x) / 2
+        } else atan2(-forward.x, -forward.z) / 2
+        return SpatialRotation(y = sin(a), w = cos(a))
+    }
+    companion object {
+        fun fromBasis(right: SpatialVector, up: SpatialVector, back: SpatialVector): SpatialRotation {
+            val m = floatArrayOf(right.x, up.x, back.x, right.y, up.y, back.y, right.z, up.z, back.z)
+            val trace = m[0] + m[4] + m[8]
+            val q = if (trace > 0) {
+                val s = sqrt(trace + 1) * 2
+                SpatialRotation((m[7]-m[5])/s, (m[2]-m[6])/s, (m[3]-m[1])/s, s/4)
+            } else {
+                val i = if (m[0] > m[4] && m[0] > m[8]) 0 else if (m[4] > m[8]) 1 else 2
+                val j = (i+1)%3; val k = (i+2)%3
+                val s = sqrt(1 + m[i*3+i] - m[j*3+j] - m[k*3+k]) * 2
+                val v = FloatArray(3)
+                v[i] = s/4; v[j] = (m[j*3+i]+m[i*3+j])/s; v[k] = (m[k*3+i]+m[i*3+k])/s
+                SpatialRotation(v[0], v[1], v[2], (m[k*3+j]-m[j*3+k])/s)
+            }
+            return q.normalized() ?: SpatialRotation()
+        }
+    }
+}
+
+data class SpatialPose(val position: SpatialVector = SpatialVector(), val rotation: SpatialRotation = SpatialRotation()) {
+    fun inverse(): SpatialPose {
+        val r = rotation.inverse()
+        return SpatialPose(r.apply(position * -1f), r)
+    }
+    operator fun times(b: SpatialPose) = SpatialPose(position + rotation.apply(b.position), rotation * b.rotation)
+    companion object {
+        fun fromSdk(v: FloatArray): SpatialPose? {
+            if (v.size != 7 || v.any { !it.isFinite() }) return null
+            val q = SpatialRotation(v[4], v[5], v[6], v[3]).normalized() ?: return null
+            return SpatialPose(SpatialVector(v[0], v[1], v[2]), q)
+        }
+    }
+}
+
+data class SpatialSample(val pose: SpatialPose, val timeNs: Long, val generation: Long, val valid: Boolean)
+data class SpatialHand(val pose: SpatialPose = SpatialPose(), val timeNs: Long = 0, val valid: Boolean = false,
+                       val trigger: Float = 0f, val grip: Boolean = false,
+                       val triggerValid: Boolean = valid, val gripValid: Boolean = valid) {
+    fun flags() = if (!valid) 0 else 1 or (if (triggerValid) 2 else 0) or (if (gripValid) 4 else 0)
+}
+
+class SpatialSession {
+    var generation: Long = 0; private set
+    var originGeneration: Long = 0; private set
+    var trackingFrameGeneration: Long = 0; private set
+    var needsRecenter = false; private set
+    val recenterPending: Boolean get() = pendingRecenter != null
+    private var pendingRecenter: Boolean? = null
+    private var recoveryAnchor: SpatialSample? = null
+    private var head: SpatialSample? = null
+    private var lastStable: SpatialSample? = null
+    private var vrOrigin: SpatialPose? = null
+    private var screenOrigin: SpatialPose? = null
+    private var hands = arrayOf(SpatialHand(), SpatialHand())
+    private val gestureEpochs = IntArray(4)
+    private val gestureEligible = BooleanArray(4)
+    private var inputsAfterNs = 0L
+    private var height = 1.6f
+    private val history = ArrayDeque<SpatialSample>()
+
+    @Synchronized fun reset(connection: Long, eyeHeight: Float, requireSetup: Boolean = false) {
+        generation = connection; height = eyeHeight.takeIf { it.isFinite() }?.coerceIn(0.5f, 2.5f) ?: 1.6f
+        originGeneration++; trackingFrameGeneration++; head = null; lastStable = null; vrOrigin = null; screenOrigin = null
+        history.clear()
+        pendingRecenter = null; recoveryAnchor = null
+        hands = arrayOf(SpatialHand(), SpatialHand()); needsRecenter = requireSetup
+        gestureEpochs.fill(0); gestureEligible.fill(false)
+        inputsAfterNs = 0L
+    }
+    @Synchronized fun accept(sample: SpatialSample): Boolean {
+        if (sample.generation != generation || sample.timeNs <= (head?.timeNs ?: 0)) return false
+        val previous = head
+        if (previous != null && sample.timeNs-previous.timeNs > 100_000_000L) invalidateHeadInputs(sample.timeNs)
+        val rotation = sample.pose.rotation.normalized()
+        val current = sample.copy(pose = sample.pose.copy(rotation = rotation ?: SpatialRotation()),
+            valid = sample.valid && sample.pose.position.finite() && rotation != null)
+        head = current
+        if (!current.valid) {
+            recoveryAnchor = null; invalidateHeadInputs(current.timeNs); return false
+        }
+        lastStable?.let {
+            val d = (current.pose.position - it.pose.position).length()
+            val a = current.pose.rotation; val b = it.pose.rotation
+            if (!needsRecenter && (d > 0.5f || abs(a.x*b.x+a.y*b.y+a.z*b.z+a.w*b.w) < 0.9238795f)) {
+                needsRecenter = true; trackingFrameGeneration++
+            }
+        }
+        pendingRecenter?.let { screen ->
+            val anchor = recoveryAnchor
+            val a = current.pose.rotation; val b = anchor?.pose?.rotation ?: a
+            if (anchor == null || previous?.valid != true || current.timeNs-previous.timeNs > 100_000_000L ||
+                (current.pose.position-anchor.pose.position).length() > 0.05f ||
+                abs(a.x*b.x+a.y*b.y+a.z*b.z+a.w*b.w) < 0.9961947f) {
+                recoveryAnchor = current
+            } else if (current.timeNs-anchor.timeNs >= 250_000_000L) {
+                applyRecenter(screen, current)
+            }
+        }
+        if (needsRecenter || recenterPending) { invalidateHeadInputs(current.timeNs); return false }
+        lastStable = current
+        history.addLast(current)
+        while (history.size > 512) history.removeFirst()
+        if (vrOrigin == null) vrOrigin = SpatialPose(current.pose.position - SpatialVector(y = height), current.pose.rotation.yaw())
+        if (screenOrigin == null) screenOrigin = current.pose
+        return true
+    }
+    @Synchronized fun setFloor(eyeHeight: Float, now: Long = System.nanoTime()) {
+        if (!eyeHeight.isFinite()) return
+        height = eyeHeight.coerceIn(0.5f, 2.5f)
+        val p = head?.takeIf { it.valid && now-it.timeNs in 0..100_000_000L }?.pose ?: return
+        vrOrigin = SpatialPose(p.position - SpatialVector(y = height), p.rotation.yaw())
+        if (needsRecenter) { history.clear(); screenOrigin = p }
+        lastStable = head; needsRecenter = false; pendingRecenter = null; recoveryAnchor = null
+        originGeneration++; invalidateHeadInputs(now)
+    }
+    @Synchronized fun recenter(screen: Boolean, now: Long = System.nanoTime()) {
+        val current = head?.takeIf { it.valid && now-it.timeNs in 0..100_000_000L }
+        if (current == null || needsRecenter || recenterPending) {
+            if (pendingRecenter == null) recoveryAnchor = null
+            pendingRecenter = screen
+            invalidateHeadInputs(now)
+            return
+        }
+        applyRecenter(screen, current)
+    }
+    private fun applyRecenter(screen: Boolean, current: SpatialSample) {
+        val p = current.pose
+        if (vrOrigin == null) vrOrigin = SpatialPose(p.position - SpatialVector(y = height), p.rotation.yaw())
+        if (screenOrigin == null) screenOrigin = p
+        if (needsRecenter) {
+            vrOrigin = SpatialPose(p.position - SpatialVector(y = height), p.rotation.yaw())
+            screenOrigin = p; originGeneration++; history.clear()
+        }
+        if (screen) screenOrigin = p else {
+            val floor = vrOrigin?.position?.y ?: (p.position.y-height)
+            vrOrigin = SpatialPose(SpatialVector(p.position.x, floor, p.position.z), p.rotation.yaw())
+            originGeneration++
+        }
+        lastStable = current; needsRecenter = false; pendingRecenter = null; recoveryAnchor = null
+        invalidateHeadInputs(current.timeNs)
+    }
+    @Synchronized fun view(screen: Boolean): SpatialPose? = lastStable?.pose?.let {
+        (if (screen) screenOrigin else vrOrigin)?.inverse()?.times(it)
+    }
+    @Synchronized fun latest() = head
+    @Synchronized fun poseAt(time: Long, connection: Long): SpatialPose? {
+        if (connection != generation || needsRecenter || recenterPending) return null
+        return history.minByOrNull { abs(it.timeNs-time) }?.takeIf { abs(it.timeNs-time) <= 12_000_000L }?.pose
+    }
+    @Synchronized fun valid(now: Long) = !needsRecenter && !recenterPending && head?.let { it.valid && now-it.timeNs in 0..100_000_000L } == true
+    @Synchronized internal fun isCurrentTrackingFrame(connection: Long, frame: Long, clock: () -> Long = System::nanoTime): Boolean =
+        connection == generation && frame == trackingFrameGeneration && valid(clock())
+    @Synchronized fun setHands(connection: Long, left: SpatialHand, right: SpatialHand) {
+        if (connection != generation || needsRecenter || recenterPending) return
+        val next = arrayOf(left, right)
+        for (index in 0..1) {
+            val oldTime = hands[index].timeNs
+            val hand = next[index]
+            if (oldTime > 0 && (hand.timeNs < oldTime || hand.timeNs-oldTime > HandObservation.MAX_AGE_NS))
+                invalidateInputs(index)
+            updateInputs(index, hand, head?.valid == true && usableHand(hand) && hand.timeNs > inputsAfterNs)
+        }
+        hands = next
+    }
+    @Synchronized fun hand(index: Int, now: Long): SpatialHand {
+        val h = hands[index]
+        val origin = vrOrigin
+        val current = origin != null && usableHand(h) && valid(now) && now-h.timeNs in 0..HandObservation.MAX_AGE_NS
+        updateInputs(index, h, current && h.timeNs > inputsAfterNs)
+        return if (origin == null) SpatialHand() else h.copy(pose = origin.inverse() * h.pose, valid = current,
+            triggerValid = h.triggerValid && gestureEligible[index*2], gripValid = h.gripValid && gestureEligible[index*2+1])
+    }
+    @Synchronized fun inputEpochs(): Int {
+        var packed = 0
+        for (index in gestureEpochs.indices) packed = packed or (gestureEpochs[index] shl (index*8))
+        return packed
+    }
+    private fun usableHand(hand: SpatialHand): Boolean {
+        val q = hand.pose.rotation
+        val norm = q.x*q.x+q.y*q.y+q.z*q.z+q.w*q.w
+        return hand.valid && hand.timeNs > 0 && hand.pose.position.finite() && norm > 0.99f && norm < 1.01f
+    }
+    private fun updateInputs(index: Int, hand: SpatialHand, valid: Boolean) {
+        updateInput(index*2, valid && hand.triggerValid && hand.trigger.isFinite() && hand.trigger in 0f..1f)
+        updateInput(index*2+1, valid && hand.gripValid)
+    }
+    private fun updateInput(index: Int, eligible: Boolean) {
+        if (gestureEligible[index] && !eligible) gestureEpochs[index] = (gestureEpochs[index]+1) and 0xff
+        gestureEligible[index] = eligible
+    }
+    private fun invalidateInputs(index: Int? = null) {
+        if (index == null) for (gesture in gestureEligible.indices) updateInput(gesture, false)
+        else { updateInput(index*2, false); updateInput(index*2+1, false) }
+    }
+    private fun invalidateHeadInputs(time: Long) {
+        inputsAfterNs = maxOf(inputsAfterNs, time)
+        hands = arrayOf(SpatialHand(), SpatialHand())
+        invalidateInputs()
+    }
+}
+
+internal data class HandObservation(val timeNs: Long, val connection: Long, val trackingFrame: Long) {
+    fun headPose(session: SpatialSession, cameraSynchronized: Boolean, now: Long? = null): SpatialPose? = synchronized(session) {
+        val checkedAt=now ?: System.nanoTime()
+        if (!cameraSynchronized || timeNs <= 0 || checkedAt-timeNs !in 0..MAX_AGE_NS ||
+            !session.isCurrentTrackingFrame(connection, trackingFrame) { checkedAt }) null
+        else session.poseAt(timeNs, connection)
+    }
+    companion object {
+        const val MAX_AGE_NS = 200_000_000L
+    }
+}
+
+internal class CameraClock {
+    private val offsets = ArrayDeque<Long>()
+    private var lastSource = 0L
+    private var lastReceipt = 0L
+    fun map(source: Long, receipt: Long): Long? {
+        if (source <= 0 || receipt <= 0) {
+            offsets.clear();lastSource=0;lastReceipt=0
+            return null
+        }
+        val offset = receipt-source
+        val skipped = lastSource > 0 && source-lastSource > 200_000_000L
+        val inconsistent = skipped && offsets.minOrNull()?.let { abs(offset-it) > 20_000_000L } == true
+        if (source <= lastSource || receipt <= lastReceipt || inconsistent) offsets.clear()
+        lastSource = source;lastReceipt = receipt
+        offsets.addLast(offset)
+        while (offsets.size > 64) offsets.removeFirst()
+        if (offsets.size < 16) return null
+        val sorted = offsets.sorted()
+        if (sorted[sorted.size*9/10]-sorted.first() > 20_000_000L) return null
+        return source+sorted.first()
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/SpatialTracking.kt

@@ -0,0 +1,208 @@
+package com.droiddeck.launcher.glasses
+
+import android.content.Context
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.wayland.WaylandCompositor
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+data class SpatialTrackingStatus(val message: String = "", val calibration: Boolean = false,
+    val frames: Long = 0, val dropped: Long = 0, val processingMs: Float = 0f,
+    val frameAgeMs: Float = -1f, val cameraHz: Float = 0f, val synchronized: Boolean = false,
+    val trackingValid: Boolean = false, val needsRecenter: Boolean = false, val recenterPending: Boolean = false,
+    val handStatus: String = "", val headFresh: Boolean = false,
+    val cameraFrameDivisor: Int = 1, val rateLimitedFrames: Long = 0, val cameraCopyPermille: Int = 1000,
+    val calibrationSource: String = "none", val calibrationVerified: Boolean = false)
+
+object SpatialTracking {
+    val session = SpatialSession()
+    private val mutableStatus = MutableStateFlow(SpatialTrackingStatus())
+    val status = mutableStatus.asStateFlow()
+    @Volatile var enabled = false; private set
+    @Volatile var handsEnabled = false; private set
+    private var context: Context? = null
+    private var engine: StereoHandEngine? = null
+    private var diagnosticsEnabled = false
+    private val buffer = ByteBuffer.allocateDirect(176).order(ByteOrder.LITTLE_ENDIAN)
+    private var lastStatus = 0L
+    @Volatile private var publisherAttached = false
+    @Volatile private var spatialSelected = false
+    private var outputUsesGlasses = true
+    private var handsSelected = false
+    private var steadyAimSelected = false
+    @Volatile private var joyConsSelected = false
+    internal val joyConsEnabled get() = enabled && joyConsSelected
+    private var hadSpatialSession = false
+    internal val selected: Boolean get() = spatialSelected
+    private fun text(id: Int) = context?.getString(id).orEmpty()
+    fun initialize(app: Context) {
+        context = app.applicationContext
+        mutableStatus.update { it.copy(
+            message = it.message.ifEmpty { text(R.string.spatial_disabled) },
+            handStatus = it.handStatus.ifEmpty { text(R.string.spatial_hands_off) },
+        ) }
+    }
+    fun attachPublisher(path: String) {
+        publisherAttached = WaylandCompositor.nativeSetSpatialFile(path)
+        publish(System.nanoTime())
+    }
+
+    internal fun connect(token: Long, generation: Long, identity: String?, spatial: Boolean, eyeHeight: Float, hands: Boolean,
+                         joyCons: Boolean = false, steadyAim: Boolean = false) {
+        engine?.close(); engine = null
+        enabled = spatial; handsEnabled = spatial && (hands || joyCons)
+        spatialSelected = spatial; handsSelected = spatial && hands && !joyCons
+        joyConsSelected = spatial && joyCons
+        steadyAimSelected = steadyAim
+        session.reset(generation, eyeHeight, spatial && hadSpatialSession)
+        hadSpatialSession = hadSpatialSession || spatial
+        if (spatial) context?.let { engine = StereoHandEngine(it, token, generation, identity) }
+        mutableStatus.value = SpatialTrackingStatus(if (spatial) text(R.string.spatial_wait_stable) else text(R.string.spatial_disabled))
+        engine?.setEnabled(handsEnabled)
+        engine?.diagnostics(diagnosticsEnabled)
+        publish(System.nanoTime())
+    }
+    internal fun disconnect() {
+        enabled = false; handsEnabled = false
+        session.reset(session.generation + 1, 1.6f)
+        publish(System.nanoTime())
+        engine?.close(); engine = null
+        mutableStatus.value = SpatialTrackingStatus(text(R.string.spatial_disconnected))
+        publish(System.nanoTime())
+    }
+    @Synchronized internal fun useLegacyTracking() {
+        spatialSelected = false; handsSelected = false; joyConsSelected = false
+        publish(System.nanoTime())
+    }
+    @Synchronized internal fun setOutputUsesGlasses(on: Boolean) {
+        if (outputUsesGlasses == on) return
+        outputUsesGlasses = on
+        publish(System.nanoTime())
+    }
+    @Synchronized internal fun accept(values: FloatArray, time: Long, generation: Long, valid: Boolean) {
+        if (!enabled || generation != session.generation) return
+        val pose = SpatialPose.fromSdk(values)
+        session.accept(SpatialSample(pose ?: SpatialPose(), time, generation, valid && pose != null))
+        publish(time)
+        if (time-lastStatus > 250_000_000L) {
+            lastStatus = time
+            refreshStatus(time)
+        }
+    }
+    @Synchronized fun refreshStatus(now: Long? = null) {
+        val checkedAt = now ?: System.nanoTime()
+        val valid = session.valid(checkedAt)
+        val pending = session.recenterPending
+        val recenter = session.needsRecenter
+        val fresh = session.latest()?.let { it.valid && checkedAt-it.timeNs in 0..100_000_000L } == true
+        mutableStatus.update { it.copy(trackingValid = valid, needsRecenter = recenter, recenterPending = pending, headFresh = fresh,
+            handStatus = engine?.handStatus?.message ?: text(R.string.spatial_hands_off),
+            message = when {
+                !enabled -> text(R.string.spatial_tracking_off)
+                pending -> text(R.string.spatial_recenter_pending)
+                !fresh -> text(R.string.spatial_tracking_lost)
+                recenter -> text(R.string.spatial_origin_changed)
+                else -> text(R.string.spatial_active)
+            }) }
+    }
+    @Synchronized fun setControllers(hands: Boolean, joyCons: Boolean) {
+        handsSelected = hands && !joyCons
+        joyConsSelected = joyCons
+        handsEnabled = enabled && (hands || joyCons)
+        session.setHands(session.generation, SpatialHand(), SpatialHand())
+        engine?.setEnabled(handsEnabled)
+        publish(System.nanoTime())
+    }
+    @Synchronized fun setSteadyHandAim(on: Boolean) {
+        steadyAimSelected = on
+        publish(System.nanoTime())
+    }
+    fun setFloor(height: Float) { session.setFloor(height); refreshStatus(); publish(System.nanoTime()) }
+    fun recenter(screen: Boolean) { session.recenter(screen); refreshStatus(); publish(System.nanoTime()) }
+    fun diagnostics(on: Boolean) { diagnosticsEnabled = on; engine?.diagnostics(on) }
+    fun calibrationStart() { engine?.startCalibration() }
+    fun calibrationCapture() { engine?.captureCalibration() }
+    fun calibrationSolve() { engine?.solveCalibration() }
+    fun calibrationValidate(distanceMeters: Float) { engine?.validateCalibration(distanceMeters) }
+    fun captureDiagnostic() { engine?.recordDiagnostic() }
+    fun setGpu(gpu: Boolean) { engine?.setGpu(gpu) }
+    fun setHandModel(lite: Boolean) { engine?.setModel(lite) }
+    fun setHandHalfRate(halfRate: Boolean) { engine?.setHalfRate(halfRate) }
+    fun setHandCpuParallel(parallel: Boolean) { engine?.setCpuParallel(parallel) }
+    fun setHandAdaptiveInput(adaptive: Boolean) { engine?.setAdaptiveInput(adaptive) }
+    fun setHandScheduledTracking(scheduled: Boolean) { engine?.setScheduledTracking(scheduled) }
+    internal fun handLiteEnabled() = (engine?.model ?: HandModel.DEFAULT) == HandModel.LITE
+    internal fun handHalfRateEnabled() = engine?.halfRateInput ?: true
+    internal fun handAdaptiveInputEnabled() = engine?.adaptiveInput ?: true
+    fun benchmarkSavedCapture(id: String) { checkNotNull(engine) { "Connect glasses and enable positional tracking" }.benchmarkSavedCapture(id) }
+    internal fun diagnosticFrame() = engine?.preview
+    internal fun diagnosticMessage() = engine?.message ?: text(R.string.spatial_connect_hint)
+    internal fun calibrationProgress() = engine?.calibrationProgress ?: SpatialCalibrationProgress()
+    internal fun gpuEnabled() = engine?.gpu ?: false
+    fun diagnosticStatus(): org.json.JSONObject {
+        val now=System.nanoTime();val sample=session.latest();val state=status.value;val progress=calibrationProgress()
+        return org.json.JSONObject().put("enabled",enabled).put("valid",session.valid(now)).put("needsRecenter",session.needsRecenter)
+            .put("joyConTracking",joyConsSelected)
+            .put("steadyHandAim",handsSelected && steadyAimSelected)
+            .put("positionEstimator",if (joyConsSelected) "joycon-wrist" else "full-palm")
+            .put("recenterPending",session.recenterPending)
+            .put("handMaxAgeMs",HandObservation.MAX_AGE_NS / 1_000_000)
+            .put("handGpuEnabled",gpuEnabled()).put("handInferenceBackend",engine?.inferenceBackend ?: "not initialized")
+            .put("handModel",(engine?.model ?: HandModel.DEFAULT).name).put("handHalfRate",handHalfRateEnabled())
+            .put("handImagePreprocessing",HandImageBuffer.PREPROCESSING)
+            .put("handLensCorrection",engine?.lensCorrection ?: "none")
+            .put("handCpuParallel",engine?.cpuParallel ?: true)
+            .put("handAdaptiveInput",handAdaptiveInputEnabled()).put("handScheduledTracking",engine?.scheduledTracking ?: true)
+            .put("handInputRatePermille",engine?.inputRatePermille ?: 500)
+            .put("handBenchmark",engine?.benchmark)
+            .put("calibrationViews",progress.views).put("calibrationCollecting",progress.collecting)
+            .put("capturePending",progress.capturing).put("captureMessage",progress.captureMessage)
+            .put("calibrationFitted",progress.fitted).put("validationPending",progress.validating).put("validationMessage",progress.validationMessage)
+            .put("calibrationIdentityAvailable",engine?.hasStableIdentity == true).put("handTracking",engine?.handStatus?.json())
+            .put("calibrationSource",engine?.calibrationSource ?: "none").put("calibrationVerified",engine?.calibrationVerified == true)
+            .put("generation",session.generation).put("origin",session.originGeneration)
+            .put("ageMs",sample?.let { (now-it.timeNs)/1e6 } ?: -1.0)
+            .put("position",sample?.pose?.position?.array()?.let { org.json.JSONArray(it.toList()) })
+            .put("message",state.message).put("camera",diagnosticMessage()).put("frames",state.frames).put("dropped",state.dropped)
+            .put("processingMs",state.processingMs.toDouble()).put("calibrated",state.calibration)
+            .put("frameAgeMs",state.frameAgeMs.toDouble()).put("cameraHz",state.cameraHz.toDouble()).put("synchronized",state.synchronized)
+            .put("cameraFrameDivisor",state.cameraFrameDivisor).put("rateLimitedFrames",state.rateLimitedFrames)
+            .put("cameraCopyPermille",state.cameraCopyPermille)
+            .put("leftValid",session.hand(0,now).valid).put("rightValid",session.hand(1,now).valid)
+    }
+    internal fun statistics(calibrated: Boolean, frames: Long, dropped: Long, ms: Float, age: Float, hz: Float, synchronized: Boolean,
+                            frameDivisor: Int, rateLimited: Long, copyPermille: Int = 1000) {
+        mutableStatus.update { it.copy(calibration = calibrated, frames = frames, dropped = dropped, processingMs = ms,
+            frameAgeMs=age,cameraHz=hz,synchronized=synchronized,cameraFrameDivisor=frameDivisor,
+            rateLimitedFrames=rateLimited,cameraCopyPermille=copyPermille,
+            calibrationSource=engine?.calibrationSource ?: "none",calibrationVerified=engine?.calibrationVerified == true) }
+    }
+    @Synchronized internal fun publish(now: Long) {
+        synchronized(session) {
+        val hands = Array(2) { session.hand(it, now) }
+        buffer.clear()
+        buffer.putInt(0x53504444).putInt(4).putInt(176).putInt(0)
+        buffer.putLong(session.generation).putLong(session.originGeneration)
+        val modes = (if (spatialSelected) 1 else 0) or (if (handsSelected) 2 else 0) or
+            (if (joyConsSelected) 4 else 0) or (if (handsSelected && steadyAimSelected) 8 else 0)
+        buffer.putInt(if (outputUsesGlasses) modes else 0).putInt(session.inputEpochs())
+        putPose(session.view(false) ?: SpatialPose(), session.latest()?.timeNs ?: 0, if(session.valid(now)) 1 else 0)
+        for (i in 0..1) {
+            val hand = hands[i]
+            putPose(hand.pose, hand.timeNs, hand.flags())
+            buffer.putFloat(if (hand.valid && hand.triggerValid) hand.trigger else 0f)
+                .putInt(if (hand.valid && hand.gripValid && hand.grip) 1 else 0)
+        }
+        buffer.flip()
+        if (publisherAttached) WaylandCompositor.nativePublishSpatial(buffer)
+        }
+    }
+    private fun putPose(p: SpatialPose, time: Long, flags: Int) {
+        buffer.putLong(time).putFloat(p.position.x).putFloat(p.position.y).putFloat(p.position.z)
+        buffer.putFloat(p.rotation.x).putFloat(p.rotation.y).putFloat(p.rotation.z).putFloat(p.rotation.w)
+        buffer.putInt(flags)
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/SteamVrSpatialGate.kt

@@ -0,0 +1,32 @@
+package com.droiddeck.launcher.glasses
+
+internal class SteamVrSpatialGate(private val settleMs: Long = 2_000) {
+    private var waiting = false
+    private var running = false
+    var deadline: Long? = null
+        private set
+
+    fun prepare(): Boolean {
+        if (running || waiting) return false
+        waiting = true
+        deadline = null
+        return true
+    }
+
+    fun setRunning(on: Boolean, now: Long): Boolean {
+        if (running == on) return false
+        running = on
+        waiting = false
+        deadline = if (on) now + settleMs else null
+        return true
+    }
+
+    fun cancel() {
+        waiting = false
+        running = false
+        deadline = null
+    }
+
+    fun spatialEnabled(requested: Boolean, now: Long) =
+        requested && !waiting && (deadline?.let { now >= it } ?: true)
+}

app/src/main/java/com/droiddeck/launcher/glasses/StereoCalibration.kt

@@ -0,0 +1,300 @@
+package com.droiddeck.launcher.glasses
+
+import android.content.Context
+import com.droiddeck.launcher.R
+import org.json.JSONArray
+import org.json.JSONObject
+import org.opencv.calib3d.Calib3d
+import org.opencv.core.*
+import org.opencv.objdetect.CharucoBoard
+import org.opencv.objdetect.CharucoDetector
+import org.opencv.objdetect.Objdetect
+import org.opencv.imgproc.Imgproc
+import java.io.File
+import kotlin.math.*
+
+internal data class BoardObservation(val objects: Mat, val left: Mat, val right: Mat, val head: SpatialPose)
+
+internal class CalibrationAlignmentException(context: Context, val deviation: Float) : IllegalArgumentException(
+    context.getString(R.string.spatial_alignment_error, SpatialMeasurements.validation(deviation)))
+
+internal class StereoCalibration(val identity: String, val width: Int, val height: Int, val fisheye: Boolean,
+    val k1: Mat, val d1: Mat, val k2: Mat, val d2: Mat, val r: Mat, val t: Mat,
+    val cameraToHead: SpatialPose, val error: Double, var verified: Boolean = false,
+    val bundledBase: Boolean = false) : AutoCloseable {
+    val readyForTracking get() = verified || bundledBase
+    val source get() = if (bundledBase && !verified) "luma-ultra-base" else "device"
+    private val p1 = Mat.zeros(3, 4, CvType.CV_64F)
+    private val p2 = Mat.zeros(3, 4, CvType.CV_64F)
+    private val undistortionMaps = Array(2) { arrayOf(Mat(),Mat()) }
+    init {
+        val a = Mat.eye(3, 4, CvType.CV_64F)
+        val b = Mat.zeros(3, 4, CvType.CV_64F)
+        r.copyTo(b.colRange(0, 3)); t.copyTo(b.col(3))
+        val empty = Mat()
+        Core.gemm(k1, a, 1.0, empty, 0.0, p1); Core.gemm(k2, b, 1.0, empty, 0.0, p2)
+        a.release(); b.release(); empty.release()
+    }
+    fun undistort(src: Mat, dst: Mat, right: Boolean) {
+        val k = if (right) k2 else k1; val d = if (right) d2 else d1
+        val maps=undistortionMaps[if(right) 1 else 0]
+        if(maps[0].empty()) {
+            val identity=Mat.eye(3,3,CvType.CV_64F)
+            try {
+                if(fisheye) Calib3d.fisheye_initUndistortRectifyMap(k,d,identity,k,src.size(),CvType.CV_16SC2,maps[0],maps[1])
+                else Calib3d.initUndistortRectifyMap(k,d,identity,k,src.size(),CvType.CV_16SC2,maps[0],maps[1])
+            } finally { identity.release() }
+        }
+        Imgproc.remap(src,dst,maps[0],maps[1],Imgproc.INTER_LINEAR)
+    }
+    fun triangulateRaw(left: List<Point>, right: List<Point>): List<SpatialVector>? {
+        val points = triangulateLandmarksRaw(left,right) ?: return null
+        return if(points.any { it == null }) null else points.filterNotNull()
+    }
+    fun triangulateLandmarksRaw(left: List<Point>, right: List<Point>): List<SpatialVector?>? {
+        if (left.size != right.size || left.isEmpty()) return null
+        val l=MatOfPoint2f(*left.toTypedArray()); val r=MatOfPoint2f(*right.toTypedArray())
+        try { return triangulateRawPoints(l,r) } finally { l.release();r.release() }
+    }
+    fun triangulateRaw(left: Mat, right: Mat): List<SpatialVector>? {
+        val points = triangulateRawPoints(left,right) ?: return null
+        return if(points.any { it == null }) null else points.filterNotNull()
+    }
+    private fun triangulateRawPoints(left: Mat, right: Mat): List<SpatialVector?>? {
+        val l=MatOfPoint2f(); val r=MatOfPoint2f(); val identity=Mat.eye(3,3,CvType.CV_64F)
+        try {
+            if (fisheye) {
+                Calib3d.fisheye_undistortPoints(left,l,k1,d1,identity,k1)
+                Calib3d.fisheye_undistortPoints(right,r,k2,d2,identity,k2)
+            } else {
+                val criteria=TermCriteria(TermCriteria.COUNT+TermCriteria.EPS,50,1e-8)
+                Calib3d.undistortPointsIter(left,l,k1,d1,identity,k1,criteria)
+                Calib3d.undistortPointsIter(right,r,k2,d2,identity,k2,criteria)
+            }
+            return triangulatePoints(l.toList(),r.toList())
+        } finally { l.release(); r.release(); identity.release() }
+    }
+    fun triangulate(left: List<Point>, right: List<Point>): List<SpatialVector>? {
+        val points = triangulatePoints(left,right) ?: return null
+        return if(points.any { it == null }) null else points.filterNotNull()
+    }
+    private fun triangulatePoints(left: List<Point>, right: List<Point>): List<SpatialVector?>? {
+        if (left.size != right.size || left.isEmpty()) return null
+        val a = Mat(2, left.size, CvType.CV_64F); val b = Mat(2, right.size, CvType.CV_64F); val out = Mat()
+        try {
+            a.put(0, 0, *left.map { it.x }.toDoubleArray()); a.put(1, 0, *left.map { it.y }.toDoubleArray())
+            b.put(0, 0, *right.map { it.x }.toDoubleArray()); b.put(1, 0, *right.map { it.y }.toDoubleArray())
+            Calib3d.triangulatePoints(p1, p2, a, b, out)
+            val projection1 = DoubleArray(12); val projection2 = DoubleArray(12)
+            p1.get(0,0,projection1); p2.get(0,0,projection2)
+            return left.indices.map { i ->
+                StereoPointValidation.reconstruct(DoubleArray(4) { out.get(it,i)[0] },
+                    doubleArrayOf(left[i].x,left[i].y),doubleArrayOf(right[i].x,right[i].y),projection1,projection2)
+            }
+        } finally { a.release(); b.release(); out.release() }
+    }
+    fun save(file: File) {
+        fun mat(m: Mat) = JSONArray((0 until m.rows()).flatMap { row -> (0 until m.cols()).map { m.get(row,it)[0] } })
+        val j = JSONObject().put("version",1).put("identity",identity).put("width",width).put("height",height)
+            .put("fisheye",fisheye).put("error",error).put("verified",verified)
+        for ((name,value) in listOf("k1" to k1,"d1" to d1,"k2" to k2,"d2" to d2,"r" to r,"t" to t))
+            j.put(name, JSONObject().put("rows",value.rows()).put("cols",value.cols()).put("data",mat(value)))
+        val p = cameraToHead.position; val q = cameraToHead.rotation
+        j.put("cameraToHead",JSONArray(listOf(p.x,p.y,p.z,q.w,q.x,q.y,q.z)))
+        file.parentFile?.mkdirs()
+        val tmp = File(file.parentFile,file.name+".tmp"); tmp.writeText(j.toString())
+        java.nio.file.Files.move(tmp.toPath(),file.toPath(),java.nio.file.StandardCopyOption.REPLACE_EXISTING)
+    }
+    override fun close() { (listOf(k1,d1,k2,d2,r,t,p1,p2)+undistortionMaps.flatMap { it.toList() }).forEach { it.release() } }
+    companion object {
+        fun load(file: File, identity: String, width: Int, height: Int): StereoCalibration? =
+            runCatching { StereoCalibrationProfile.parse(file.readText(), identity, width, height)?.let(::fromProfile) }.getOrNull()
+
+        fun fromProfile(profile: StereoCalibrationProfile): StereoCalibration {
+            val matrices = mutableListOf<Mat>()
+            try {
+                profile.matrices.forEach { data ->
+                    val matrix = Mat(data.rows, data.columns, CvType.CV_64F)
+                    matrices.add(matrix)
+                    matrix.put(0, 0, *data.values)
+                }
+                return StereoCalibration(profile.identity, profile.width, profile.height, profile.fisheye,
+                    matrices[0], matrices[1], matrices[2], matrices[3], matrices[4], matrices[5],
+                    profile.cameraToHead, profile.error, profile.verified, profile.bundledBase)
+            } catch (e: Exception) {
+                matrices.forEach(Mat::release)
+                throw e
+            }
+        }
+    }
+}
+
+internal class StereoCalibrator(private val context: Context) : AutoCloseable {
+    val board = CharucoBoard(Size(5.0,7.0),0.03f,0.022f,Objdetect.getPredefinedDictionary(Objdetect.DICT_4X4_50))
+    private val detector = CharucoDetector(board)
+    val observations = mutableListOf<BoardObservation>()
+    var commonCorners: Int = 0; private set
+    fun detect(left: Mat, right: Mat, head: SpatialPose): BoardObservation? {
+        val lc=Mat(); val li=Mat(); val rc=Mat(); val ri=Mat()
+        try {
+            detector.detectBoard(left,lc,li); detector.detectBoard(right,rc,ri)
+            val l=(0 until li.rows()).associate { li.get(it,0)[0].toInt() to lc.get(it,0) }
+            val r=(0 until ri.rows()).associate { ri.get(it,0)[0].toInt() to rc.get(it,0) }
+            val ids=l.keys.intersect(r.keys).sorted()
+            commonCorners = ids.size
+            if (ids.size<12) return null
+            val objects=MatOfPoint3f(*ids.map { Point3((it%4+1)*0.03,(it/4+1)*0.03,0.0) }.toTypedArray())
+            return BoardObservation(objects,MatOfPoint2f(*ids.map { Point(l[it]!![0],l[it]!![1]) }.toTypedArray()),
+                MatOfPoint2f(*ids.map { Point(r[it]!![0],r[it]!![1]) }.toTypedArray()),head)
+        } finally { listOf(lc,li,rc,ri).forEach { it.release() } }
+    }
+    fun solve(identity: String,width: Int,height: Int): StereoCalibration {
+        require(observations.size>=24) { context.getString(R.string.spatial_need_views) }
+        val initial=observations.first().head.rotation
+        val axes=observations.map { initial.inverse()*it.head.rotation }.map { SpatialVector(it.x,it.y,it.z) }
+        require(axes.any { a -> axes.any { b -> a.cross(b).length()>0.02f } }) { context.getString(R.string.spatial_need_rotation) }
+        val training=observations.filterIndexed { i,_ -> i%5!=0 }; val held=observations.filterIndexed { i,_ -> i%5==0 }
+        val failures = mutableListOf<Pair<String, Exception>>()
+        val candidates=listOf(false,true).mapNotNull { fish ->
+            try { fit(identity,width,height,fish,training,held) }
+            catch (e: Exception) {
+                val model = if (fish) "Fisheye" else "Pinhole"
+                android.util.Log.w("StereoCalibration", "$model calibration failed", e)
+                failures.add(model to e)
+                null
+            }
+        }
+        val best=candidates.minByOrNull { it.error } ?: run {
+            val alignment=failures.map { it.second }.filterIsInstance<CalibrationAlignmentException>().minByOrNull { it.deviation }
+            val reason=alignment?.message ?: failures.joinToString(" ") { (model,e) ->
+                "$model: ${e.message?.substringBefore('\n') ?: e.javaClass.simpleName}"
+            }
+            error(context.getString(R.string.spatial_calibration_error, reason))
+        }
+        candidates.filter { it !== best }.forEach { it.close() }
+        if(best.error>2.0) { best.close(); error(context.getString(R.string.spatial_reprojection_error, best.error)) }
+        return best
+    }
+    private fun fit(identity: String,w: Int,h: Int,fish: Boolean,train: List<BoardObservation>,held: List<BoardObservation>): StereoCalibration {
+        val k1=Mat.eye(3,3,CvType.CV_64F); val k2=Mat.eye(3,3,CvType.CV_64F)
+        val d1=Mat.zeros(if(fish) 4 else 5,1,CvType.CV_64F); val d2=d1.clone()
+        val r=Mat(); val t=Mat(); val objects=train.map { it.objects }; val size=Size(w.toDouble(),h.toDouble())
+        fun intrinsic(k: Mat,d: Mat,images: List<Mat>) {
+            val rv=mutableListOf<Mat>(); val tv=mutableListOf<Mat>()
+            try {
+                if(fish) Calib3d.fisheye_calibrate(objects,images,size,k,d,rv,tv,Calib3d.fisheye_CALIB_RECOMPUTE_EXTRINSIC or Calib3d.fisheye_CALIB_FIX_SKEW)
+                else Calib3d.calibrateCamera(objects,images,size,k,d,rv,tv)
+            } finally { (rv+tv).forEach { it.release() } }
+        }
+        try {
+            intrinsic(k1,d1,train.map { it.left }); intrinsic(k2,d2,train.map { it.right })
+            stereoGeometry(objects,train.map{it.left},train.map{it.right},k1,d1,k2,d2,size,fish,r,t)
+            require(Core.norm(t) in 0.02..0.3) { context.getString(R.string.spatial_bad_baseline) }
+            val hr=mutableListOf<Mat>(); val ht=mutableListOf<Mat>(); val br=mutableListOf<Mat>(); val bt=mutableListOf<Mat>()
+            val camR=Mat(); val camT=Mat()
+            try {
+                for(o in train) {
+                    val rv=Mat(); val tv=Mat(); val rotation=Mat()
+                    boardPose(o.objects,o.left,k1,d1,fish,rv,tv)
+                    Calib3d.Rodrigues(rv,rotation); rv.release(); br.add(rotation); bt.add(tv)
+                    hr.add(matrix(o.head.rotation)); ht.add(vector(o.head.position))
+                }
+                Calib3d.calibrateHandEye(hr,ht,br,bt,camR,camT,Calib3d.CALIB_HAND_EYE_PARK)
+                require(Core.checkRange(camR) && Core.checkRange(camT) && Core.norm(camT)<0.3) { context.getString(R.string.spatial_need_orientations) }
+                val cameraToHead=pose(camR,camT)
+                require(abs(Core.determinant(camR)-1.0)<0.01) { context.getString(R.string.spatial_bad_rotation) }
+                val boardWorld=held.map { o ->
+                    val rv=Mat();val tv=Mat();val rotation=Mat()
+                    try {
+                        boardPose(o.objects,o.left,k1,d1,fish,rv,tv);Calib3d.Rodrigues(rv,rotation)
+                        o.head*cameraToHead*pose(rotation,tv)
+                    } finally { rv.release();tv.release();rotation.release() }
+                }
+                val center=boardWorld.map { it.position }.reduce { a,b -> a+b }*(1f/boardWorld.size)
+                val drift = boardWorld.maxOf { (it.position-center).length() }
+                if (drift>=0.05f) throw CalibrationAlignmentException(context,drift)
+                val orientation=boardWorld.first().rotation
+                require(boardWorld.all { val q=orientation.inverse()*it.rotation;abs(q.w)>cos(Math.toRadians(8.0)/2) }) { context.getString(R.string.spatial_bad_alignment) }
+                val error=held.map { reprojection(it,k1,d1,k2,d2,r,t,fish) }.average()
+                require(error.isFinite())
+                return StereoCalibration(identity,w,h,fish,k1,d1,k2,d2,r,t,cameraToHead,error)
+            } finally { (hr+ht+br+bt+listOf(camR,camT)).forEach { it.release() } }
+        } catch(e: Exception) { listOf(k1,k2,d1,d2,r,t).forEach { it.release() }; throw e }
+    }
+    private fun boardPose(objects: Mat,pixels: Mat,k: Mat,d: Mat,fish: Boolean,rv: Mat,tv: Mat) {
+        val ok=if(fish) Calib3d.fisheye_solvePnP(objects,pixels,k,d,rv,tv)
+            else {
+                val obj=MatOfPoint3f(objects); val img=MatOfPoint2f(pixels); val dist=MatOfDouble(d)
+                try { Calib3d.solvePnP(obj,img,k,dist,rv,tv) } finally { obj.release(); img.release(); dist.release() }
+            }
+        require(ok)
+    }
+    private fun reprojection(o: BoardObservation,k1: Mat,d1: Mat,k2: Mat,d2: Mat,r: Mat,t: Mat,fish: Boolean): Double {
+        val rv=Mat(); val tv=Mat(); val rot=Mat(); val rightR=Mat(); val rightT=Mat(); val rightV=Mat(); val empty=Mat()
+        val predicted=MatOfPoint2f(); val objectPoints=MatOfPoint3f(o.objects); val dist=MatOfDouble(d2)
+        try {
+            boardPose(o.objects,o.left,k1,d1,fish,rv,tv); Calib3d.Rodrigues(rv,rot)
+            Core.gemm(r,rot,1.0,empty,0.0,rightR); Core.gemm(r,tv,1.0,t,1.0,rightT); Calib3d.Rodrigues(rightR,rightV)
+            if(fish) Calib3d.fisheye_projectPoints(o.objects,predicted,rightV,rightT,k2,d2)
+            else Calib3d.projectPoints(objectPoints,rightV,rightT,k2,dist,predicted)
+            return Core.norm(predicted,o.right,Core.NORM_L2)/sqrt(o.right.rows().toDouble())
+        } finally { listOf(rv,tv,rot,rightR,rightT,rightV,empty,predicted,objectPoints,dist).forEach { it.release() } }
+    }
+    override fun close() { observations.forEach { listOf(it.objects,it.left,it.right).forEach(Mat::release) }; observations.clear(); detector.clear() }
+    fun save(file: File, identity: String, width: Int, height: Int) {
+        fun points(m: Mat) = JSONArray((0 until m.rows()).map { row -> JSONArray(m.get(row,0).toList()) })
+        val views = JSONArray(observations.map { o ->
+            val p=o.head.position; val q=o.head.rotation
+            JSONObject().put("objects",points(o.objects)).put("left",points(o.left)).put("right",points(o.right))
+                .put("head",JSONArray(listOf(p.x,p.y,p.z,q.w,q.x,q.y,q.z)))
+        })
+        val data=JSONObject().put("version",1).put("identity",identity).put("width",width).put("height",height).put("views",views)
+        file.parentFile?.mkdirs()
+        val temporary=File(file.parentFile,file.name+".tmp")
+        temporary.writeText(data.toString())
+        java.nio.file.Files.move(temporary.toPath(),file.toPath(),java.nio.file.StandardCopyOption.REPLACE_EXISTING)
+    }
+    companion object {
+        fun load(context: Context, file: File, identity: String, width: Int, height: Int): StereoCalibrator? {
+            if (!file.isFile) return null
+            val restored=StereoCalibrator(context)
+            try {
+                val data=JSONObject(file.readText())
+                require(data.getInt("version")==1 && data.getString("identity")==identity && data.getInt("width")==width && data.getInt("height")==height)
+                val views=data.getJSONArray("views")
+                require(views.length() in 1..1000)
+                for (i in 0 until views.length()) {
+                    val view=views.getJSONObject(i)
+                    val points=CalibrationObservationData.parse(view)
+                    restored.observations.add(BoardObservation(
+                        MatOfPoint3f(*points.objects.map { Point3(it[0],it[1],it[2]) }.toTypedArray()),
+                        MatOfPoint2f(*points.left.map { Point(it[0],it[1]) }.toTypedArray()),
+                        MatOfPoint2f(*points.right.map { Point(it[0],it[1]) }.toTypedArray()),points.head))
+                }
+                return restored
+            } catch (e: Exception) {
+                restored.close()
+                android.util.Log.w("StereoCalibration", "Saved captures could not be restored", e)
+                return null
+            }
+        }
+        internal fun stereoGeometry(objects: List<Mat>, left: List<Mat>, right: List<Mat>, k1: Mat,d1: Mat,k2: Mat,d2: Mat,
+            size: Size,fish: Boolean,r: Mat,t: Mat) {
+            val e=Mat(); val f=Mat(); val identity=Mat.eye(3,3,CvType.CV_64F); val zero=Mat.zeros(5,1,CvType.CV_64F)
+            val corrected=mutableListOf<Mat>()
+            fun images(input: List<Mat>, k: Mat,d: Mat) = if (!fish) input else input.map { pixels ->
+                Mat().also { output -> corrected.add(output); Calib3d.fisheye_undistortPoints(pixels,output,k,d,identity,k) }
+            }
+            try {
+                // OpenCV 4.13 fisheye stereo fitting assumes equal corner counts in every view.
+                Calib3d.stereoCalibrate(objects,images(left,k1,d1),images(right,k2,d2),k1,if(fish)zero else d1,k2,if(fish)zero else d2,
+                    size,r,t,e,f,Calib3d.CALIB_FIX_INTRINSIC)
+            } finally { (corrected+listOf(e,f,identity,zero)).forEach(Mat::release) }
+        }
+        fun matrix(q: SpatialRotation)=Mat(3,3,CvType.CV_64F).also { it.put(0,0,*q.matrix().map(Float::toDouble).toDoubleArray()) }
+        fun vector(p: SpatialVector)=Mat(3,1,CvType.CV_64F).also { it.put(0,0,p.x.toDouble(),p.y.toDouble(),p.z.toDouble()) }
+        fun pose(r: Mat,t: Mat)=SpatialPose(SpatialVector(t.get(0,0)[0].toFloat(),t.get(1,0)[0].toFloat(),t.get(2,0)[0].toFloat()),
+            SpatialRotation.fromBasis(column(r,0),column(r,1),column(r,2)))
+        private fun column(r: Mat,c: Int)=SpatialVector(r.get(0,c)[0].toFloat(),r.get(1,c)[0].toFloat(),r.get(2,c)[0].toFloat())
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/StereoCalibrationProfile.kt

@@ -0,0 +1,51 @@
+package com.droiddeck.launcher.glasses
+
+import org.json.JSONObject
+
+internal data class CalibrationMatrix(val rows: Int, val columns: Int, val values: DoubleArray)
+
+internal data class StereoCalibrationProfile(
+    val identity: String, val width: Int, val height: Int, val fisheye: Boolean,
+    val matrices: List<CalibrationMatrix>, val cameraToHead: SpatialPose, val error: Double,
+    val verified: Boolean, val bundledBase: Boolean = false,
+) {
+    companion object {
+        const val BASE_ASSET = "calibration/luma-ultra-640x480.json"
+        const val BASE_IDENTITY = "luma-ultra-base-v1"
+
+        fun select(saved: String?, base: () -> String?, identity: String?, width: Int, height: Int): StereoCalibrationProfile? {
+            if (identity != null && saved != null) parse(saved, identity, width, height)?.let { return it }
+            return base()?.let { parse(it, identity ?: BASE_IDENTITY, width, height, bundledBase = true) }
+        }
+
+        fun parse(text: String, identity: String, width: Int, height: Int,
+                  bundledBase: Boolean = false): StereoCalibrationProfile? = runCatching {
+            val data = JSONObject(text)
+            require(data.getInt("version") == 1 && data.getInt("width") == width && data.getInt("height") == height)
+            if (bundledBase) {
+                require(data.getString("identity") == BASE_IDENTITY && data.getString("deviceModel") == "VITURE Luma Ultra")
+                require(data.getString("cameraPair") == "left0-right0" && width == 640 && height == 480)
+            } else require(data.getString("identity") == identity)
+            val fisheye = data.getBoolean("fisheye")
+            val matrices = listOf("k1", "d1", "k2", "d2", "r", "t").map { name ->
+                val matrix = data.getJSONObject(name)
+                val rows = matrix.getInt("rows"); val columns = matrix.getInt("cols")
+                val values = matrix.getJSONArray("data")
+                require(rows in 1..14 && columns in 1..14 && values.length() == rows * columns)
+                CalibrationMatrix(rows, columns, DoubleArray(values.length()) { values.getDouble(it).also { n -> require(n.isFinite()) } })
+            }
+            require(listOf(0, 2, 4).all { matrices[it].rows == 3 && matrices[it].columns == 3 })
+            require(matrices[5].rows == 3 && matrices[5].columns == 1)
+            require(listOf(1, 3).all {
+                val matrix = matrices[it]
+                (matrix.rows == 1 || matrix.columns == 1) && matrix.values.size in if (fisheye) listOf(4) else listOf(4, 5, 8, 12, 14)
+            })
+            require(listOf(0, 2).all { matrices[it].values[0] > 0 && matrices[it].values[4] > 0 })
+            val pose = data.getJSONArray("cameraToHead"); require(pose.length() == 7)
+            val cameraToHead = SpatialPose.fromSdk(FloatArray(7) { pose.getDouble(it).toFloat() }) ?: error("Invalid camera transform")
+            val error = data.getDouble("error"); require(error.isFinite() && error in 0.0..2.0)
+            StereoCalibrationProfile(identity, width, height, fisheye, matrices, cameraToHead, error,
+                verified = !bundledBase && data.getBoolean("verified"), bundledBase = bundledBase)
+        }.getOrNull()
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/StereoFingerGestures.kt

@@ -0,0 +1,67 @@
+package com.droiddeck.launcher.glasses
+
+import kotlin.math.abs
+import kotlin.math.min
+
+internal object StereoFingerGestures {
+    data class Result(val trigger: Float = 0f, val triggerValid: Boolean = false,
+                      val grip: Boolean = false, val gripValid: Boolean = false)
+
+    fun estimate(left: List<SpatialVector>?, right: List<SpatialVector>?, gripping: Boolean): Result {
+        val a = View.create(left) ?: return Result()
+        val b = View.create(right) ?: return Result()
+        val triggerA = a.pinch()
+        val triggerB = b.pinch()
+        val triggerValid = triggerA != null && triggerB != null && abs(triggerA-triggerB) <= 0.30f
+        val curls = listOf(9,13,17).map { base ->
+            val ca = a.curl(base)
+            val cb = b.curl(base)
+            if (ca != null && cb != null && abs(ca-cb) <= 0.45f) min(ca,cb) else null
+        }
+        val gripValid = curls.all { it != null }
+        val closed = curls.count { it != null && it >= (if (gripping) 0.40f else 0.65f) }
+        return Result(if (triggerValid) min(triggerA!!,triggerB!!) else 0f,triggerValid,
+            gripValid && closed >= (if (gripping) 2 else 3),gripValid)
+    }
+
+    private class View(val points: List<SpatialVector>,val width: Float) {
+        private fun point(index: Int) = points[index].takeIf(SpatialVector::finite)
+            ?.let { SpatialVector(it.x,it.y) }
+
+        fun pinch(): Float? {
+            val thumb = point(4) ?: return null
+            val index = point(8) ?: return null
+            val wrist = point(0) ?: return null
+            if ((thumb-wrist).length() > width*3.5f || (index-wrist).length() > width*3.5f) return null
+            return ((0.55f-(thumb-index).length()/width)/0.35f).coerceIn(0f,1f)
+        }
+
+        fun curl(base: Int): Float? {
+            val wrist = point(0) ?: return null
+            val joints = (base..base+3).map { point(it) ?: return null }
+            val lengths = joints.zipWithNext { a,b -> (b-a).length() }
+            if (lengths.any { it < width*0.005f }) return null
+            val path = lengths.sum()
+            val reach = (joints[0]-wrist).length()
+            if (path !in width*0.15f..width*3f || reach < width*0.20f) return null
+            val shortness = ((1.7f-(joints[3]-wrist).length()/reach)/0.55f).coerceIn(0f,1f)
+            val bend = ((1f-(joints[3]-joints[0]).length()/path)/0.35f).coerceIn(0f,1f)
+            return min(shortness,bend)
+        }
+
+        companion object {
+            fun create(points: List<SpatialVector>?): View? {
+                if (points?.size != 21) return null
+                if (listOf(0,5,9,13,17).any { !points[it].finite() }) return null
+                fun xy(index: Int) = SpatialVector(points[index].x,points[index].y)
+                val across = xy(5)-xy(17)
+                val along = xy(9)-xy(0)
+                val width = across.length()
+                val length = along.length()
+                if (!width.isFinite() || !length.isFinite() || width < 1e-3f || length < 1e-3f) return null
+                if (width/length !in 0.25f..3f || abs(across.cross(along).z)/(width*length) < 0.15f) return null
+                return View(points,width)
+            }
+        }
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/StereoHandEngine.kt

@@ -0,0 +1,650 @@
+package com.droiddeck.launcher.glasses
+
+import android.content.Context
+import com.droiddeck.launcher.R
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import com.google.mediapipe.framework.image.MPImage
+import com.google.mediapipe.tasks.core.BaseOptions
+import com.google.mediapipe.tasks.core.Delegate
+import com.google.mediapipe.tasks.vision.core.RunningMode
+import com.google.mediapipe.tasks.vision.handlandmarker.HandLandmarker
+import org.opencv.android.OpenCVLoader
+import org.opencv.android.Utils
+import org.opencv.core.*
+import org.opencv.imgproc.Imgproc
+import org.opencv.imgcodecs.Imgcodecs
+import org.json.JSONObject
+import java.io.File
+import java.nio.ByteBuffer
+import java.security.MessageDigest
+import java.util.concurrent.ConcurrentLinkedQueue
+
+internal data class HandTrackingDiagnostics(val message: String, val leftCameraHands: Int = 0,
+    val rightCameraHands: Int = 0, val matched: Int = 0, val reconstructed: Int = 0, val accepted: Int = 0,
+    val preprocessMs: Float = 0f, val inferenceMs: Float = 0f,
+    val triggerValid: Int = 0, val gripValid: Int = 0,
+    val leftRawHands: Int = 0, val rightRawHands: Int = 0,
+    val previousLeftRawHands: Int = -1, val previousRightRawHands: Int = -1,
+    val leftInferenceMs: Float = 0f, val rightInferenceMs: Float = 0f,
+    val inferenceHandLimit: Int = 2,
+    val observationTimeNs: Long = 0, val observationAgeMs: Float = -1f,
+    val left: HandObservationDiagnostic? = null, val right: HandObservationDiagnostic? = null,
+    val observations: HandTrackingMetricSnapshot? = null) {
+    fun json() = JSONObject().put("message",message).put("experimental",true).put("leftCameraHands",leftCameraHands)
+        .put("rightCameraHands",rightCameraHands).put("matched",matched).put("reconstructed",reconstructed).put("accepted",accepted)
+        .put("preprocessMs",preprocessMs.toDouble()).put("inferenceMs",inferenceMs.toDouble())
+        .put("triggerValid",triggerValid).put("gripValid",gripValid)
+        .put("leftRawHands",leftRawHands).put("rightRawHands",rightRawHands)
+        .put("previousLeftRawHands",previousLeftRawHands).put("previousRightRawHands",previousRightRawHands)
+        .put("leftInferenceMs",leftInferenceMs.toDouble()).put("rightInferenceMs",rightInferenceMs.toDouble())
+        .put("inferenceHandLimit",inferenceHandLimit)
+        .put("observationTimeNs",observationTimeNs).put("observationAgeMs",observationAgeMs.toDouble())
+        .put("left",left?.json()).put("right",right?.json()).put("observations",observations?.json())
+}
+
+private fun HandObservationDiagnostic.json() = JSONObject().put("outcome",outcome.name.lowercase())
+    .put("positionSource",positionSource)
+    .put("reconstructedPalmLandmarks",org.json.JSONArray(reconstructedPalmLandmarks))
+    .put("accepted",accepted).put("triggerEstimate",triggerEstimate.toDouble())
+    .put("triggerGeometryValid",triggerGeometryValid).put("triggerValid",triggerValid)
+    .put("gripEstimate",gripEstimate).put("gripGeometryValid",gripGeometryValid).put("gripValid",gripValid)
+
+private fun HandSideMetrics.json() = JSONObject().put("observations",observations).put("accepted",accepted)
+    .put("triggerValid",triggerValid).put("gripValid",gripValid)
+    .put("triggerAboveClickThreshold",triggerAboveClickThreshold).put("triggerReleased",triggerReleased)
+    .put("gripPressed",gripPressed).put("trackingLosses",trackingLosses)
+    .put("triggerLosses",triggerLosses).put("gripLosses",gripLosses)
+    .put("maximumConsecutiveRejected",maximumConsecutiveRejected)
+    .put("outcomes",JSONObject().also { json -> outcomes.forEach { (outcome,count) -> json.put(outcome.name.lowercase(),count) } })
+
+private fun HandTrackingMetricSnapshot.json() = JSONObject().put("processedPairs",processedPairs).put("inferencePairs",inferencePairs)
+    .put("scope","Processed camera pairs in this tracking connection, including absent hands and setup; not detection accuracy")
+    .put("left",left.json()).put("right",right.json())
+
+internal class StereoHandEngine(private val context: Context, private val token: Long,
+    private val generation: Long, private val identity: String?) : AutoCloseable {
+    @Volatile private var running=true
+    @Volatile private var enabled=false
+    @Volatile private var debug=false
+    @Volatile var preview: Bitmap? = null; private set
+    @Volatile var message=context.getString(R.string.spatial_wait_cameras); private set
+    @Volatile var calibrationProgress = SpatialCalibrationProgress(); private set
+    @Volatile var handStatus = HandTrackingDiagnostics(context.getString(R.string.spatial_wait_hands)); private set
+    val hasStableIdentity get() = identity != null
+    private val commands=ConcurrentLinkedQueue<() -> Unit>()
+    private var calibrator: StereoCalibrator?=null
+    private var calibrationFrame = 0L
+    private var calibration: StereoCalibration?=null
+    val calibrationSource get() = calibration?.source ?: "none"
+    val calibrationVerified get() = calibration?.verified == true
+    val lensCorrection get() = calibration?.let { if(it.fisheye) "fisheye-points-only" else "pinhole-points-only" } ?: "none"
+    private var capture=false
+    private var record=false
+    private var verify: Float?=null
+    private var validationRequestedAt=0L
+    @Volatile var gpu=false; private set
+    @Volatile var model=HandModel.DEFAULT; private set
+    @Volatile var halfRateInput=true; private set
+    @Volatile var adaptiveInput=true; private set
+    @Volatile var scheduledTracking=true; private set
+    @Volatile var inputRatePermille=500; private set
+    @Volatile var cpuParallel=true; private set
+    @Volatile var benchmark: JSONObject?=null; private set
+    @Volatile var inferenceBackend: String? = null; private set
+    private var detectors: DetectorBank?=null
+    private var fastDetectors: DetectorBank?=null
+    private var rightWorker: StereoInferenceRunner?=null
+    private val inferenceSchedule=HandInferenceSchedule()
+    private val processingRate=HandProcessingRate()
+    private val handMetrics=HandTrackingMetrics()
+    private val gestures=Array(2) { HandGestures(rightHand=it==1) }
+    private val joyConPositions=Array(2) { JoyConWristPosition() }
+    private var joyConFlow: StereoJoyConFlow? = null
+    private val profile: File get() {
+        val hash=MessageDigest.getInstance("SHA-256").digest((identity ?: "session:$generation").toByteArray()).joinToString("") { "%02x".format(it) }
+        return File(context.filesDir,"spatial/calibration-$hash.json")
+    }
+    private val captures: File get() = File(profile.parentFile,profile.nameWithoutExtension+"-captures.json")
+    private fun saveCaptures() {
+        try { calibrator?.save(captures,identity ?: "session:$generation",width,height) }
+        catch (e: Exception) { android.util.Log.w("StereoCalibration", "Could not save captured views", e) }
+    }
+    fun setEnabled(on: Boolean) { enabled=on }
+    fun diagnostics(on: Boolean) { debug=on }
+    fun setGpu(on: Boolean) { commands.add { clearHands();closeDetectors();gpu=on } }
+    fun setModel(lite: Boolean) { commands.add {
+        clearHands();closeDetectors();model=if(lite) HandModel.LITE else HandModel.FULL
+    } }
+    fun setHalfRate(on: Boolean) { commands.add { adaptiveInput=false;halfRateInput=on;processingRate.reset() } }
+    fun setAdaptiveInput(on: Boolean) { commands.add { adaptiveInput=on;processingRate.reset() } }
+    fun setScheduledTracking(on: Boolean) { commands.add { clearHands();closeDetectors();scheduledTracking=on } }
+    fun setCpuParallel(on: Boolean) { commands.add { clearHands();closeDetectors();cpuParallel=on } }
+    fun benchmarkSavedCapture(id: String) {
+        require(id.matches(Regex("[0-9]{1,20}")))
+        benchmark=JSONObject().put("state","pending").put("capture",id)
+        commands.add {
+            try { benchmark=benchmarkCapture(id) }
+            catch(e: Exception) { benchmark=JSONObject().put("state","failed").put("error",e.message) }
+        }
+    }
+    fun startCalibration() { debug=true; commands.add {
+        check(width > 0 && height > 0) { context.getString(R.string.spatial_wait_previews) }
+        calibrator?.close();calibrator=StereoCalibrator(context)
+        calibrationFrame = SpatialTracking.session.trackingFrameGeneration
+        calibrationProgress = SpatialCalibrationProgress(collecting = true)
+        saveCaptures()
+        message=context.getString(R.string.spatial_collect_instructions)
+    } }
+    fun captureCalibration() { commands.add {
+        check(calibrationProgress.collecting && calibrationFrame==SpatialTracking.session.trackingFrameGeneration) {
+            context.getString(R.string.spatial_saved_views_hint)
+        }
+        capture=true
+        calibrationProgress = calibrationProgress.copy(capturing = true, captureMessage = context.getString(R.string.spatial_capture_pending))
+    } }
+    fun recordDiagnostic() { commands.add { record=true } }
+    fun validateCalibration(distance: Float) { commands.add {
+        require(distance.isFinite() && distance in 0.15f..1.5f)
+        verify=distance;validationRequestedAt=System.nanoTime()
+        calibrationProgress=calibrationProgress.copy(validating=true,
+            validationMessage=context.getString(R.string.spatial_validation_pending))
+    } }
+    private var width=0; private var height=0
+    private val imageBuffer=HandImageBuffer()
+    private val rightImageBuffer=HandImageBuffer()
+    private val worker=Thread({ loop() },"viture-stereo-hands").apply { isDaemon=true; start() }
+    fun solveCalibration() { commands.add {
+        val c=calibrator ?: error(context.getString(R.string.spatial_start_first))
+        saveCaptures()
+        calibrationProgress = calibrationProgress.copy(solving = true, validationMessage = null)
+        try {
+            val fitted=c.solve(identity ?: "session:$generation",width,height)
+            clearHands();closeDetectors()
+            calibration?.close();calibration=fitted
+            calibrationProgress = calibrationProgress.copy(fitted = true)
+            if(identity!=null) fitted.save(profile)
+            message=context.getString(R.string.spatial_fit_ready, fitted.error)
+        } finally { calibrationProgress = calibrationProgress.copy(solving = false) }
+    } }
+    private fun detector(selected: HandModel=model, useGpu: Boolean=gpu, maxHands: Int=2): HandLandmarker {
+        val bytes=context.assets.open(selected.asset).use { it.readBytes() }
+        val hash=MessageDigest.getInstance("SHA-256").digest(bytes).joinToString("") { "%02x".format(it) }
+        check(hash==selected.sha256) { context.getString(R.string.spatial_model_checksum_error) }
+        return HandLandmarker.createFromOptions(context,HandLandmarker.HandLandmarkerOptions.builder()
+            .setBaseOptions(BaseOptions.builder().setModelAssetPath(selected.asset)
+                .setDelegate(if(useGpu) Delegate.GPU else Delegate.CPU).build())
+            .setRunningMode(RunningMode.VIDEO).setNumHands(maxHands).setMinHandDetectionConfidence(0.6f)
+            .setMinHandPresenceConfidence(0.6f).setMinTrackingConfidence(0.6f).build())
+    }
+    private data class Detection(val side: Int,val points: List<Point>)
+    private data class Detections(val hands: List<Detection>,val rawCount: Int,val inferenceMs: Float)
+    private class DetectorBank(val left: HandLandmarker, val right: HandLandmarker, val maxHands: Int) {
+        var previousLeftRaw=-1
+        var previousRightRaw=-1
+    }
+    private fun createBank(selected: HandModel, useGpu: Boolean, maxHands: Int,
+                           worker: StereoInferenceRunner?): DetectorBank {
+        val left=detector(selected,useGpu,maxHands)
+        try {
+            val right=worker?.onRight { detector(selected,useGpu,maxHands) } ?: detector(selected,useGpu,maxHands)
+            return DetectorBank(left,right,maxHands)
+        } catch(e: Throwable) { left.close();throw e }
+    }
+    private fun closeBank(bank: DetectorBank?, worker: StereoInferenceRunner?) {
+        if(bank==null) return
+        try { bank.left.close() } finally {
+            if(worker!=null) worker.onRight { bank.right.close() } else bank.right.close()
+        }
+    }
+    private fun imagePoints(detection: Detection?) = detection?.points?.map {
+        SpatialVector(it.x.toFloat(),it.y.toFloat(),0f)
+    }
+    private fun detect(detector: HandLandmarker, bitmap: Bitmap, stamp: Long, buffer: HandImageBuffer,
+                       wristOnly: Boolean): Detections =
+        detect(detector,stamp,wristOnly) { buffer.image(bitmap) }
+    private fun detect(detector: HandLandmarker, stamp: Long, wristOnly: Boolean,
+                       prepareImage: () -> MPImage): Detections {
+        val image=prepareImage()
+        try {
+            val start=System.nanoTime()
+            val result=detector.detectForVideo(image,stamp)
+            val elapsed=(System.nanoTime()-start)/1e6f
+            val hands=result.landmarks().mapIndexedNotNull { i, hand ->
+                val category=result.handedness()[i].firstOrNull() ?: return@mapIndexedNotNull null
+                if(category.score()<0.6f) return@mapIndexedNotNull null
+                val points=if(wristOnly) hand.take(1) else hand
+                Detection(if(category.categoryName()=="Left") 0 else 1,points.map { Point(it.x()*image.width.toDouble(),it.y()*image.height.toDouble()) })
+            }
+            return Detections(hands,result.landmarks().size,elapsed)
+        } finally { image.close() }
+    }
+    private fun closeDetectors() {
+        inferenceBackend=null
+        inferenceSchedule.reset();processingRate.reset()
+        val search=detectors;val fast=fastDetectors;val worker=rightWorker
+        detectors=null;fastDetectors=null;rightWorker=null
+        try { closeBank(search,worker) } finally {
+            try { closeBank(fast,worker) } finally { worker?.close() }
+        }
+    }
+    private fun detectPair(left: HandLandmarker, right: HandLandmarker, leftImage: Bitmap,
+                           rightImage: Bitmap, stamp: Long, worker: StereoInferenceRunner?, wristOnly: Boolean): Pair<Detections,Detections> {
+        val l={ detect(left,leftImage,stamp,imageBuffer,wristOnly) };val r={ detect(right,rightImage,stamp,rightImageBuffer,wristOnly) }
+        return worker?.pair(l,r) ?: (l() to r())
+    }
+    private fun detectRawPair(left: HandLandmarker, right: HandLandmarker, leftGray: ByteArray,
+                              rightGray: ByteArray, stamp: Long, worker: StereoInferenceRunner?, wristOnly: Boolean): Pair<Detections,Detections> {
+        val l={ detect(left,stamp,wristOnly) { imageBuffer.image(leftGray,width,height) } }
+        val r={ detect(right,stamp,wristOnly) { rightImageBuffer.image(rightGray,width,height) } }
+        return worker?.pair(l,r) ?: (l() to r())
+    }
+    private fun benchmarkCapture(id: String): JSONObject {
+        val folder=File(context.filesDir,"spatial/captures/$id")
+        val c=calibration ?: error("Load the saved calibration before benchmarking")
+        val wristOnly=SpatialTracking.joyConsEnabled
+        val gray=ArrayList<Mat>();val images=ArrayList<Bitmap>();val rows=org.json.JSONArray()
+        clearHands();closeDetectors()
+        try {
+            for(name in listOf("left","right")) {
+                val source=Imgcodecs.imread(File(folder,"$name.png").path,Imgcodecs.IMREAD_GRAYSCALE)
+                gray.add(source)
+                check(source.cols()==width && source.rows()==height) { "Saved pair has incompatible dimensions" }
+                val rgba=Mat()
+                try {
+                    Imgproc.cvtColor(source,rgba,Imgproc.COLOR_GRAY2RGBA)
+                    val bitmap=Bitmap.createBitmap(width,height,Bitmap.Config.ARGB_8888)
+                    images.add(bitmap);Utils.matToBitmap(rgba,bitmap)
+                } finally { rgba.release() }
+            }
+            for((selected,parallel,scheduled) in listOf(Triple(HandModel.FULL,true,false),Triple(HandModel.FULL,true,true),
+                Triple(HandModel.LITE,true,true),Triple(HandModel.FULL,true,false))) {
+                var search: DetectorBank?=null;var fast: DetectorBank?=null
+                val schedule=HandInferenceSchedule()
+                val worker=if(parallel) StereoInferenceRunner() else null
+                val times=ArrayList<Double>();val samples=org.json.JSONArray()
+                try {
+                    search=createBank(selected,false,2,worker)
+                    if(scheduled) fast=createBank(selected,false,1,worker)
+                    repeat(24) { frame ->
+                        check(running) { "Tracking stopped during benchmark" }
+                        val start=System.nanoTime();val stamp=1000L+frame*80L
+                        val bank=if(scheduled && schedule.select(stamp)==1) fast!! else search
+                        val (leftResult,rightResult)=detectPair(bank.left,bank.right,images[0],images[1],stamp,worker,wristOnly)
+                        val l=leftResult.hands;val r=rightResult.hands
+                        if(scheduled) schedule.observe(stamp,l.map { it.side },r.map { it.side },leftResult.rawCount,rightResult.rawCount)
+                        val ms=(System.nanoTime()-start)/1e6
+                        val hands=org.json.JSONArray()
+                        val joyCons=org.json.JSONArray()
+                        val wrists=org.json.JSONArray()
+                        for(side in 0..1) {
+                            val a=l.singleOrNull { it.side==side };val b=r.singleOrNull { it.side==side }
+                            val points=if(a!=null && b!=null) c.triangulateLandmarksRaw(a.points,b.points) else null
+                            points?.get(0)?.takeIf { it.finite() }?.let { wrist ->
+                                wrists.put(JSONObject().put("side",side).put("position",org.json.JSONArray(wrist.array().toList())))
+                            }
+                            val hand=if(wristOnly) null else points?.let { HandGestures(rightHand=side==1).estimate(it,SpatialPose(),stamp*1_000_000,imagePoints(a),imagePoints(b)) }
+                            val joyCon=if(wristOnly) points?.let { JoyConWristPosition().estimate(it,SpatialPose(),stamp*1_000_000) } else null
+                            if(joyCon!=null) joyCons.put(JSONObject().put("side",side)
+                                .put("position",org.json.JSONArray(joyCon.pose.position.array().toList())))
+                            if(hand!=null) hands.put(JSONObject().put("side",side).put("flags",hand.flags())
+                                .put("position",org.json.JSONArray(hand.pose.position.array().toList()))
+                                .put("trigger",hand.trigger.toDouble()).put("grip",hand.grip))
+                        }
+                        if(frame>=4) {
+                            times.add(ms);samples.put(JSONObject().put("left",l.size).put("right",r.size).put("hands",hands)
+                                .put("joyCons",joyCons).put("wrists",wrists)
+                                .put("inferenceHandLimit",bank.maxHands)
+                                .put("leftRawHands",leftResult.rawCount).put("rightRawHands",rightResult.rawCount)
+                                .put("leftInferenceMs",leftResult.inferenceMs.toDouble()).put("rightInferenceMs",rightResult.inferenceMs.toDouble()))
+                        }
+                    }
+                } finally {
+                    try { closeBank(search,worker) } finally {
+                        try { closeBank(fast,worker) } finally { worker?.close() }
+                    }
+                }
+                val sorted=times.sorted()
+                rows.put(JSONObject().put("model",selected.name).put("parallel",parallel).put("medianMs",(sorted[9]+sorted[10])/2)
+                    .put("scheduled",scheduled)
+                    .put("p95Ms",sorted[18]).put("samples",samples))
+            }
+            return JSONObject().put("state","completed").put("capture",id).put("backend","CPU")
+                .put("wristOnly",wristOnly).put("imagePreprocessing",HandImageBuffer.PREPROCESSING)
+                .put("lensCorrection",lensCorrection)
+                .put("scope","Saved stereo pair replay; not live tracking or external latency").put("results",rows)
+        } finally { gray.forEach { it.release() };images.forEach { it.recycle() };clearHands() }
+    }
+    private fun clearHands() {
+        gestures.forEach { it.reset() }
+        joyConPositions.forEach { it.reset() }
+        joyConFlow?.reset()
+        inferenceSchedule.reset();processingRate.reset()
+        SpatialTracking.session.setHands(generation,SpatialHand(),SpatialHand())
+    }
+    private fun loop() {
+        try { check(OpenCVLoader.initLocal()) } catch(e: Throwable) { message=context.getString(R.string.spatial_opencv_error, e.message.orEmpty());return }
+        var grayL=Mat();var grayR=Mat();val rgba=Mat()
+        var bmpL: Bitmap?=null;var bmpR: Bitmap?=null
+        var leftGray=ByteArray(0);var rightGray=ByteArray(0)
+        val left=ByteBuffer.allocateDirect(2048*2048);val right=ByteBuffer.allocateDirect(2048*2048)
+        val metadata=DoubleArray(9);val headData=FloatArray(7)
+        var lastSeq=0L;var dropped=0L;var frames=0L;var previewTime=0L
+        val clock=CameraClock()
+        var lastSource=0L;var lastStamp=0L;var captureOn=false;var captureRate=1000;var lastInputSeq=0L
+        var rate=0f
+        try {
+            check(OpenCVLoader.initLocal()) { context.getString(R.string.spatial_opencv_load_error) }
+            joyConFlow=StereoJoyConFlow()
+            while(running) {
+                while(true) {
+                    val command=commands.poll() ?: break
+                    try { command() } catch(e: Exception) { message=e.message ?: e.toString() }
+                }
+                if (verify!=null && System.nanoTime()-validationRequestedAt>2_000_000_000L) {
+                    verify=null
+                    calibrationProgress=calibrationProgress.copy(validating=false,
+                        validationMessage=context.getString(R.string.spatial_no_camera_frame))
+                }
+                val want=enabled || debug
+                val copyPermille=if(enabled && !calibrationProgress.collecting && !capture && verify==null && !record)
+                    if(adaptiveInput && !gpu) processingRate.permille else if(halfRateInput) 500 else 1000
+                    else 1000
+                inputRatePermille=copyPermille
+                if(want!=captureOn || copyPermille!=captureRate) {
+                    VitureSdk.nativeCapture(token,want,copyPermille);captureOn=want;captureRate=copyPermille
+                    if(!want) clearHands()
+                }
+                if(!want) { Thread.sleep(20);continue }
+                val seq=VitureSdk.nativeStereo(token,left,right,metadata,headData,!enabled || capture)
+                if(seq<=0) { Thread.sleep(5);continue }
+                val sequenceDelta=if(lastSeq>0) (seq-lastSeq).coerceAtLeast(1) else 1
+                if(lastSeq>0) dropped+=(sequenceDelta-1)
+                lastSeq=seq;frames++
+                val start=System.nanoTime();val source=(metadata[2]*1e9).toLong();val receipt=metadata[3].toLong()
+                val inputSequence=metadata[7].toLong()
+                if(source<=lastSource) { clearHands();message=context.getString(R.string.spatial_clock_reset);closeDetectors();lastStamp=0 }
+                if(lastSource>0 && source>lastSource) {
+                    val hz=1e9f*(inputSequence-lastInputSeq).coerceAtLeast(1)/(source-lastSource)
+                    rate=if(rate==0f)hz else rate*.9f+hz*.1f
+                }
+                lastSource=source;lastInputSeq=inputSequence
+                val time=clock.map(source,receipt) ?: 0L
+                val trackingFrame = SpatialTracking.session.trackingFrameGeneration
+                if (calibrator != null && calibrationProgress.collecting && calibrationFrame != trackingFrame) {
+                    capture=false
+                    message=context.getString(R.string.spatial_frame_changed)
+                    calibrationProgress = calibrationProgress.copy(collecting = false, capturing = false, captureMessage = message)
+                }
+                // The callback pose's basis is undocumented; use canonical GL pose history.
+                val observation=HandObservation(time,generation,trackingFrame)
+                var captureHead=observation.headPose(SpatialTracking.session,metadata[6]>0)
+                val w=metadata[0].toInt();val h=metadata[1].toInt()
+                if(w!=width || h!=height) {
+                    clearHands();closeDetectors()
+                    width=w;height=h;leftGray=ByteArray(w*h);rightGray=ByteArray(w*h)
+                    grayL.release();grayR.release();grayL=Mat(h,w,CvType.CV_8UC1);grayR=Mat(h,w,CvType.CV_8UC1)
+                    bmpL?.recycle();bmpR?.recycle();bmpL=null;bmpR=null
+                    calibration?.close()
+                    val selected=StereoCalibrationProfile.select(
+                        if(identity!=null) runCatching { profile.readText() }.getOrNull() else null,
+                        { runCatching { context.assets.open(StereoCalibrationProfile.BASE_ASSET).bufferedReader().use { it.readText() } }.getOrNull() },
+                        identity,w,h)
+                    calibration=selected?.let(StereoCalibration::fromProfile)
+                    calibrator?.close();calibrator=null
+                    calibrationProgress = SpatialCalibrationProgress(fitted = calibration != null)
+                    message=context.getString(R.string.spatial_stereo_loaded, w, h, when {
+                        calibration?.verified==true -> context.getString(R.string.spatial_device_loaded)
+                        calibration?.bundledBase==true -> context.getString(R.string.spatial_base_loaded)
+                        else -> context.getString(R.string.spatial_calibration_needed)
+                    })
+                    if (identity!=null) calibrator=StereoCalibrator.load(context,captures,identity,w,h)
+                    calibrator?.let {
+                        calibrationFrame=-1
+                        val restored=context.getString(R.string.spatial_restored, it.observations.size)
+                        calibrationProgress=calibrationProgress.copy(views=it.observations.size,captureMessage=restored)
+                        message=restored
+                    }
+                }
+                left.position(0);left.get(leftGray)
+                right.position(0);right.get(rightGray)
+                val joyConMode=SpatialTracking.joyConsEnabled
+                val drawPreview=debug && start-previewTime>150_000_000L
+                if(capture || verify!=null || record || drawPreview || joyConMode) {
+                    grayL.put(0,0,leftGray);grayR.put(0,0,rightGray)
+                }
+                if(capture) {
+                    capture=false
+                    val observation=captureHead?.let { calibrator?.detect(grayL,grayR,it) }
+                    val currentTracking = SpatialTracking.session.isCurrentTrackingFrame(generation, trackingFrame)
+                    if(observation!=null && currentTracking) {
+                        calibrator!!.observations.add(observation)
+                        calibrationProgress = calibrationProgress.copy(views = calibrator!!.observations.size)
+                        saveCaptures()
+                        message=context.getString(R.string.spatial_captured, calibrator!!.observations.size)
+                    } else {
+                        observation?.let { listOf(it.objects,it.left,it.right).forEach(Mat::release) }
+                        message = when {
+                            calibrator == null -> context.getString(R.string.spatial_tap_start)
+                            SpatialTracking.session.recenterPending -> context.getString(R.string.spatial_capture_recenter_pending)
+                            SpatialTracking.session.needsRecenter -> context.getString(R.string.spatial_capture_recenter)
+                            captureHead == null || !currentTracking -> context.getString(R.string.spatial_capture_unsynchronized)
+                            else -> context.getString(R.string.spatial_capture_corners, calibrator?.commonCorners ?: 0)
+                        }
+                    }
+                    calibrationProgress = calibrationProgress.copy(capturing = false, captureMessage = message)
+                }
+                val c=calibration
+                val distance=verify
+                if(distance!=null) {
+                    verify=null
+                    var temporary: StereoCalibrator?=null
+                    var observed: BoardObservation?=null
+                    try {
+                        check(c!=null) { context.getString(R.string.spatial_align_first) }
+                        temporary=StereoCalibrator(context)
+                        observed=temporary.detect(grayL,grayR,SpatialPose())
+                        val points=observed?.let { c.triangulateRaw(it.left,it.right) }
+                        val result=CalibrationDistanceCheck.evaluate(context,distance,temporary.commonCorners,points)
+                        if(result.accepted) {
+                            c.verified=true;if(identity!=null)c.save(profile)
+                            calibrationProgress=calibrationProgress.copy(validationMessage=result.message+
+                                if(identity==null) " " + context.getString(R.string.spatial_validation_session) else " " + context.getString(R.string.spatial_validation_saved))
+                        } else calibrationProgress=calibrationProgress.copy(validationMessage=result.message)
+                    } catch (e: Exception) {
+                        android.util.Log.w("StereoCalibration","Distance validation failed",e)
+                        calibrationProgress=calibrationProgress.copy(validationMessage=context.getString(R.string.spatial_validation_error, e.message?.substringBefore('\n') ?: context.getString(R.string.spatial_processing_failed)))
+                    } finally {
+                        calibrationProgress=calibrationProgress.copy(validating=false)
+                        observed?.let { listOf(it.objects,it.left,it.right).forEach(Mat::release) };temporary?.close()
+                    }
+                }
+                var dl=emptyList<Detection>();var dr=emptyList<Detection>()
+                var trackingHealthy=false
+                var inferred=false
+                val sideDiagnostics=Array(2) { HandObservationDiagnostic(HandObservationOutcome.NO_MATCHING_DETECTION) }
+                val nextStatus: HandTrackingDiagnostics
+                if(enabled && c?.readyForTracking==true && time>0 && SpatialTracking.session.isCurrentTrackingFrame(generation, trackingFrame) && System.nanoTime()-time in 0..HandObservation.MAX_AGE_NS) {
+                    val preprocessMs=(System.nanoTime()-start)/1e6f
+                    if(detectors==null) {
+                        try {
+                            rightWorker=if(cpuParallel && !gpu) StereoInferenceRunner() else null
+                            detectors=createBank(model,gpu,2,rightWorker)
+                            if(scheduledTracking && !gpu) fastDetectors=createBank(model,false,1,rightWorker)
+                            inferenceBackend=if(gpu) "GPU" else "CPU"
+                        }
+                        catch(e: Exception) {
+                            closeDetectors()
+                            enabled=false;clearHands();message=context.getString(R.string.spatial_inference_error, e.message.orEmpty())
+                            val unavailable=HandObservationDiagnostic(HandObservationOutcome.INFERENCE_UNAVAILABLE)
+                            handMetrics.observe(seq,false,unavailable,unavailable)
+                            handStatus=HandTrackingDiagnostics(message,observationTimeNs=time,
+                                observationAgeMs=(System.nanoTime()-time)/1e6f,left=unavailable,right=unavailable,observations=handMetrics.snapshot())
+                            continue
+                        }
+                    }
+                    val stamp=maxOf(time/1_000_000,lastStamp+1);lastStamp=stamp
+                    val inferenceStart=System.nanoTime()
+                    val scheduled=scheduledTracking && !gpu
+                    val bank=if(scheduled && inferenceSchedule.select(stamp)==1) fastDetectors!! else detectors!!
+                    val pair=detectRawPair(bank.left,bank.right,leftGray,rightGray,stamp,rightWorker,joyConMode)
+                    inferred=true
+                    dl=pair.first.hands;dr=pair.second.hands
+                    if(scheduled) inferenceSchedule.observe(stamp,dl.map { it.side },dr.map { it.side },pair.first.rawCount,pair.second.rawCount)
+                    val inferenceMs=(System.nanoTime()-inferenceStart)/1e6f
+                    // VIO callbacks can arrive during inference; verify this exact camera stamp before publishing.
+                    captureHead=observation.headPose(SpatialTracking.session,
+                        metadata[6]>0 || VitureSdk.nativeCameraSynchronized(token,metadata[2]))
+                    val hands=Array(2) { SpatialHand() }
+                    if (joyConMode) joyConFlow?.begin(grayL,grayR,time) else joyConFlow?.reset()
+                    var matched=0;var reconstructed=0
+                    for(side in 0..1) {
+                        val leftCandidates=dl.filter { it.side==side };val rightCandidates=dr.filter { it.side==side }
+                        val l=leftCandidates.singleOrNull();val r=rightCandidates.singleOrNull()
+                        val detectedPoints=if(l!=null && r!=null) {
+                            matched++
+                            c.triangulateLandmarksRaw(l.points,r.points)
+                        } else null
+                        var points=detectedPoints
+                        if(points?.any { it != null }==true) reconstructed++
+                        var hand=points?.let { p -> captureHead?.let { head ->
+                            if (joyConMode) joyConPositions[side].estimate(p,head*c.cameraToHead,time)
+                            else gestures[side].estimate(p,head*c.cameraToHead,time,imagePoints(l),imagePoints(r))
+                        } }
+                        var positionSource=if(hand!=null) "landmarks" else "none"
+                        if (joyConMode && captureHead!=null) {
+                            if (hand!=null && l!=null && r!=null && detectedPoints!=null)
+                                joyConFlow?.seed(side,l.points.first(),r.points.first(),time)
+                            else if (leftCandidates.size<=1 && rightCandidates.size<=1) {
+                                joyConFlow?.points(side)?.let { tracked ->
+                                    val flowed=c.triangulateLandmarksRaw(tracked.left,tracked.right)
+                                    val position=flowed?.let { joyConPositions[side].estimate(it,captureHead!!*c.cameraToHead,time) }
+                                    if(position!=null) { hand=position;points=flowed;positionSource="stereo_flow" }
+                                }
+                            }
+                        }
+                        val outcome=when {
+                            hand!=null -> HandObservationOutcome.ACCEPTED
+                            leftCandidates.size>1 || rightCandidates.size>1 -> HandObservationOutcome.AMBIGUOUS_HANDEDNESS
+                            l==null && r==null -> HandObservationOutcome.NO_MATCHING_DETECTION
+                            l==null || r==null -> HandObservationOutcome.ONE_CAMERA_ONLY
+                            points?.any { it != null }!=true -> HandObservationOutcome.STEREO_REJECTED
+                            captureHead==null -> HandObservationOutcome.CAMERA_NOT_SYNCHRONIZED
+                            else -> if (joyConMode) joyConPositions[side].lastOutcome else gestures[side].lastOutcome
+                        }
+                        sideDiagnostics[side]=HandObservationDiagnostic(outcome,
+                            listOf(0,5,9,13,17).filter { points?.getOrNull(it)?.finite()==true },
+                            hand?.trigger ?: 0f,hand?.triggerValid ?: false,hand?.grip ?: false,hand?.gripValid ?: false,positionSource)
+                        if (hand!=null) hands[side]=hand
+                        else if (joyConMode) gestures[side].reset()
+                        else gestures[side].resetAfterRejection(outcome)
+                    }
+                    if (joyConMode) joyConFlow?.end(grayL,grayR,time)
+                    val current=SpatialTracking.session.isCurrentTrackingFrame(generation, trackingFrame) &&
+                        joyConMode==SpatialTracking.joyConsEnabled
+                    val fresh=System.nanoTime()-time in 0..HandObservation.MAX_AGE_NS
+                    if (current && fresh)
+                        SpatialTracking.session.setHands(generation,hands[0],hands[1])
+                    else {
+                        clearHands()
+                        for(side in 0..1) sideDiagnostics[side]=sideDiagnostics[side].copy(outcome=
+                            if(!current) HandObservationOutcome.HEAD_TRACKING_INVALID else HandObservationOutcome.STALE_OBSERVATION)
+                    }
+                    val accepted=if(current && fresh) hands.count { it.valid } else 0
+                    trackingHealthy=accepted>0
+                    nextStatus=HandTrackingDiagnostics(when {
+                        !current -> context.getString(R.string.spatial_hand_head_changed)
+                        !fresh -> context.getString(R.string.spatial_hand_timeout, HandObservation.MAX_AGE_NS / 1_000_000)
+                        captureHead==null -> context.getString(R.string.spatial_hand_wait_sync)
+                        accepted>0 && joyConMode -> context.getString(R.string.spatial_wrists_tracked, accepted)
+                        accepted>0 -> context.getString(R.string.spatial_palms_tracked, accepted, hands.count { it.valid && it.triggerValid }, hands.count { it.valid && it.gripValid })
+                        dl.isEmpty() && dr.isEmpty() && joyConMode -> context.getString(R.string.spatial_no_wrists)
+                        dl.isEmpty() && dr.isEmpty() -> context.getString(R.string.spatial_no_hands)
+                        (dl.isEmpty() || dr.isEmpty()) && joyConMode -> context.getString(R.string.spatial_one_camera_wrists)
+                        dl.isEmpty() || dr.isEmpty() -> context.getString(R.string.spatial_one_camera_hands)
+                        matched==0 -> context.getString(R.string.spatial_ambiguous_hands)
+                        reconstructed==0 -> context.getString(R.string.spatial_inconsistent_depth)
+                        joyConMode -> context.getString(R.string.spatial_rejected_wrist)
+                        else -> context.getString(R.string.spatial_inconsistent_palm)
+                    },dl.size,dr.size,matched,reconstructed,accepted,preprocessMs,inferenceMs,
+                        if(current && fresh) hands.count { it.valid && it.triggerValid } else 0,
+                        if(current && fresh) hands.count { it.valid && it.gripValid } else 0,
+                        pair.first.rawCount,pair.second.rawCount,bank.previousLeftRaw,bank.previousRightRaw,
+                        pair.first.inferenceMs,pair.second.inferenceMs,bank.maxHands)
+                    bank.previousLeftRaw=pair.first.rawCount;bank.previousRightRaw=pair.second.rawCount
+                } else {
+                    clearHands()
+                    val outcome=when {
+                        !enabled -> HandObservationOutcome.DISABLED
+                        c?.readyForTracking!=true -> HandObservationOutcome.CALIBRATION_REQUIRED
+                        time<=0 -> HandObservationOutcome.CLOCK_NOT_READY
+                        !SpatialTracking.session.isCurrentTrackingFrame(generation,trackingFrame) -> HandObservationOutcome.HEAD_TRACKING_INVALID
+                        else -> HandObservationOutcome.STALE_OBSERVATION
+                    }
+                    for(side in 0..1) sideDiagnostics[side]=HandObservationDiagnostic(outcome)
+                    nextStatus=HandTrackingDiagnostics(when {
+                        !enabled -> context.getString(R.string.spatial_hands_off)
+                        c?.readyForTracking!=true -> context.getString(R.string.spatial_hands_need_calibration)
+                        captureHead==null -> context.getString(R.string.spatial_hand_wait_sync)
+                        !SpatialTracking.session.isCurrentTrackingFrame(generation,trackingFrame) -> context.getString(R.string.spatial_hands_wait_stable)
+                        else -> context.getString(R.string.spatial_old_frame)
+                    })
+                }
+                handMetrics.observe(seq,inferred,sideDiagnostics[0],sideDiagnostics[1])
+                handStatus=nextStatus.copy(observationTimeNs=time,
+                    observationAgeMs=if(time>0) (System.nanoTime()-time)/1e6f else -1f,
+                    left=sideDiagnostics[0],right=sideDiagnostics[1],observations=handMetrics.snapshot())
+                if(drawPreview) {
+                    previewTime=start
+                    if(bmpL==null) bmpL=Bitmap.createBitmap(w,h,Bitmap.Config.ARGB_8888)
+                    if(bmpR==null) bmpR=Bitmap.createBitmap(w,h,Bitmap.Config.ARGB_8888)
+                    Imgproc.cvtColor(grayL,rgba,Imgproc.COLOR_GRAY2RGBA);Utils.matToBitmap(rgba,bmpL)
+                    Imgproc.cvtColor(grayR,rgba,Imgproc.COLOR_GRAY2RGBA);Utils.matToBitmap(rgba,bmpR)
+                    val combined=Bitmap.createBitmap(w*2,h,Bitmap.Config.ARGB_8888);val canvas=Canvas(combined)
+                    canvas.drawBitmap(bmpL!!,0f,0f,null);canvas.drawBitmap(bmpR!!,w.toFloat(),0f,null)
+                    val paint=Paint().apply { color=Color.GREEN;strokeWidth=3f }
+                    for((index,detections) in listOf(dl,dr).withIndex()) for(d in detections) for(p in d.points)
+                        canvas.drawCircle(p.x.toFloat()+index*w,p.y.toFloat(),3f,paint)
+                    preview=combined
+                }
+                if(record) {
+                    record=false
+                    val folder=File(context.filesDir,"spatial/captures/$receipt").apply { mkdirs() }
+                    Imgcodecs.imwrite(File(folder,"left.png").path,grayL);Imgcodecs.imwrite(File(folder,"right.png").path,grayR)
+                    File(folder,"frame.json").writeText(JSONObject().put("sourceSeconds",metadata[2]).put("receiptNs",receipt)
+                        .put("connection",generation).put("width",w).put("height",h).put("pairedPose",captureHead!=null).toString())
+                    message=context.getString(R.string.spatial_capture_saved, folder.path)
+                }
+                if(running && generation==SpatialTracking.session.generation) {
+                    val finished=System.nanoTime()
+                    if(adaptiveInput && !gpu) processingRate.observe(finished-start,if(time>0) finished-time else -1,trackingHealthy)
+                    SpatialTracking.statistics(c?.readyForTracking==true,frames,dropped,(finished-start)/1e6f,
+                        if(time>0)(finished-time)/1e6f else -1f,rate,captureHead!=null,
+                        when(copyPermille) { 500 -> 2;1000 -> 1;else -> 0 },metadata[8].toLong(),copyPermille)
+                    SpatialTracking.publish(System.nanoTime())
+                }
+            }
+        } catch(e: InterruptedException) { /* Shutdown interrupts the idle wait. */ }
+        catch(e: Throwable) {
+            message=context.getString(R.string.spatial_hand_error, e.message.orEmpty())
+            val unavailable=HandObservationDiagnostic(HandObservationOutcome.INFERENCE_UNAVAILABLE)
+            handStatus=HandTrackingDiagnostics(message,left=unavailable,right=unavailable,observations=handMetrics.snapshot())
+            calibrationProgress = calibrationProgress.copy(capturing = false, captureMessage = message,
+                validating = false, validationMessage = if(calibrationProgress.validating) message else calibrationProgress.validationMessage)
+            clearHands()
+        }
+        finally {
+            VitureSdk.nativeCapture(token,false,1000)
+            joyConFlow?.close();joyConFlow=null
+            closeDetectors()
+            calibration?.close();calibrator?.close()
+            listOf(grayL,grayR,rgba).forEach(Mat::release);bmpL?.recycle();bmpR?.recycle()
+        }
+    }
+    override fun close() {
+        running=false;worker.interrupt()
+        if(Thread.currentThread()!==worker) worker.join(2000)
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/StereoInferenceRunner.kt

@@ -0,0 +1,38 @@
+package com.droiddeck.launcher.glasses
+
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.Executors
+import java.util.concurrent.Future
+
+internal class StereoInferenceRunner : AutoCloseable {
+    private val worker = Executors.newSingleThreadExecutor { task ->
+        Thread(task, "viture-right-hand").apply { isDaemon = true }
+    }
+
+    fun <T> onRight(action: () -> T): T = worker.submit<T> { action() }.completed()
+
+    fun <T> pair(left: () -> T, right: () -> T): Pair<T, T> {
+        val pending = worker.submit<T> { right() }
+        val result = try { left() } catch (error: Throwable) {
+            try { pending.completed() } catch (other: Throwable) { if (other !== error) error.addSuppressed(other) }
+            throw error
+        }
+        return result to pending.completed()
+    }
+
+    override fun close() { worker.shutdown() }
+
+    private fun <T> Future<T>.completed(): T {
+        var interrupted = false
+        try {
+            while (true) {
+                try { return get() }
+                catch (e: InterruptedException) { interrupted = true }
+                catch (e: ExecutionException) { throw e.cause ?: e }
+            }
+        } finally {
+            // Native inference must finish before either camera's pixels or detector can be reused.
+            if (interrupted) Thread.currentThread().interrupt()
+        }
+    }
+}

app/src/main/java/com/droiddeck/launcher/glasses/StereoJoyConFlow.kt

@@ -0,0 +1,72 @@
+package com.droiddeck.launcher.glasses
+
+import org.opencv.core.*
+import org.opencv.video.Video
+
+internal class StereoJoyConFlow : AutoCloseable {
+    data class Points(val left: List<Point>, val right: List<Point>, val seedNs: Long)
+    private val previousLeft = Mat()
+    private val previousRight = Mat()
+    private val tracks = arrayOfNulls<Points>(2)
+    private var previousTime = 0L
+
+    fun reset() {
+        previousTime = 0
+        tracks.fill(null)
+        previousLeft.release(); previousRight.release()
+    }
+
+    fun begin(left: Mat, right: Mat, time: Long) {
+        for (side in 0..1) {
+            val old = tracks[side] ?: continue
+            if (!JoyConFlowGate.fresh(old.seedNs, previousTime, time) ||
+                previousLeft.size() != left.size() || previousRight.size() != right.size()) {
+                tracks[side] = null
+                continue
+            }
+            tracks[side] = try {
+                Points(follow(previousLeft, left, old.left), follow(previousRight, right, old.right), old.seedNs)
+            } catch (e: CvException) {
+                android.util.Log.w("StereoJoyConFlow", "Discarding failed optical flow", e)
+                null
+            }
+        }
+    }
+
+    fun points(side: Int): Points? = tracks[side]
+
+    fun seed(side: Int, left: Point, right: Point, time: Long) {
+        tracks[side] = Points(listOf(Point(left.x, left.y)), listOf(Point(right.x, right.y)), time)
+    }
+
+    fun end(left: Mat, right: Mat, time: Long) {
+        left.copyTo(previousLeft); right.copyTo(previousRight); previousTime = time
+    }
+
+    private fun follow(previous: Mat, current: Mat, points: List<Point>): List<Point> {
+        val indices = points.indices.filter { points[it].x.isFinite() && points[it].y.isFinite() }
+        val result = MutableList(points.size) { missing() }
+        if (indices.isEmpty()) return result
+        val before = MatOfPoint2f(*indices.map { points[it] }.toTypedArray())
+        val after = MatOfPoint2f(); val back = MatOfPoint2f()
+        val forwardStatus = MatOfByte(); val backStatus = MatOfByte()
+        val error = MatOfFloat(); val backError = MatOfFloat()
+        try {
+            Video.calcOpticalFlowPyrLK(previous, current, before, after, forwardStatus, error)
+            Video.calcOpticalFlowPyrLK(current, previous, after, back, backStatus, backError)
+            val next = after.toArray(); val returned = back.toArray()
+            val valid = forwardStatus.toArray(); val validBack = backStatus.toArray(); val errors = error.toArray()
+            for ((i, index) in indices.withIndex()) {
+                val n = next[i]; val b = returned[i]; val p = points[index]
+                if (JoyConFlowGate.point(n.x,n.y,b.x,b.y,p.x,p.y,errors[i],valid[i].toInt()!=0,
+                        validBack[i].toInt()!=0,current.cols(),current.rows())) result[index] = n
+            }
+        } finally {
+            listOf(before, after, back, forwardStatus, backStatus, error, backError).forEach(Mat::release)
+        }
+        return result
+    }
+
+    private fun missing() = Point(Double.NaN, Double.NaN)
+    override fun close() = reset()
+}

app/src/main/java/com/droiddeck/launcher/glasses/StereoPointValidation.kt

@@ -0,0 +1,21 @@
+package com.droiddeck.launcher.glasses
+
+import kotlin.math.abs
+import kotlin.math.hypot
+
+internal object StereoPointValidation {
+    fun reconstruct(homogeneous: DoubleArray, left: DoubleArray, right: DoubleArray,
+                    p1: DoubleArray, p2: DoubleArray): SpatialVector? {
+        if (homogeneous.size != 4 || left.size != 2 || right.size != 2 || p1.size != 12 || p2.size != 12) return null
+        val w = homogeneous[3]
+        if (!w.isFinite() || abs(w) < 1e-8) return null
+        val v = DoubleArray(3) { homogeneous[it]/w }
+        if (v.any { !it.isFinite() } || v[2] !in 0.15..1.5) return null
+        for ((projection,pixel) in listOf(p1 to left,p2 to right)) {
+            val q = DoubleArray(3) { row -> (0..2).sumOf { projection[row*4+it]*v[it] } + projection[row*4+3] }
+            if (q.any { !it.isFinite() } || pixel.any { !it.isFinite() } || q[2] <= 0 ||
+                hypot(q[0]/q[2]-pixel[0],q[1]/q[2]-pixel[1]) > 3.0) return null
+        }
+        return SpatialVector(v[0].toFloat(),v[1].toFloat(),v[2].toFloat())
+    }
+}