Screens: a reset button next to the grab bar, clickable in VR games

Each desktop screen gets a reset button left of its bar (a reticle). It puts every screen back in its layout around where you are now, like Meta+Shift+R (ft-layout apply). In a VR game the screens leave the controllers to the game (the outside_games and dashboard modes), so a controller couldn't click any of their controls. Aiming a hand controller at the reset button now sets MakeOverlaysInteractiveIfVisible on that button's overlay alone, so the trigger clicks it; the flag clears half a second after the aim leaves a zone twice as wide, and the game gets the controllers back. The aim comes from the laser poses ft-screens already reads to show the controls. The ft-layout spawn is now RunLayout(cmd), shared with the arrange. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Merge branch perf (dynamic per-screen frame rates, idle pointer, remote on demand, lighter gaze) into experimental
2026-10-06 07:00:14 +02:00 · 2026-10-03 21:15:48 -06:00 · 2026-10-03 17:10:34 -06:00 · 2026-10-03 14:35:37 -06:00 · 2026-10-03 14:35:18 -06:00 · 2026-10-03 14:24:39 -06:00
34 changed files with 120 additions and 1341 deletions
@@ -26,7 +26,7 @@ A Steam Frame is someone's personal headset, and they may be wearing it while yo

 - Don't kill or restart `gamescope`, `steam`, `vrserver`, `vrcompositor`, the gamescope session, or the Frametop desktop without asking. Each one ends or disrupts whatever is happening in VR.
 - Don't run host `sudo`, `steamos-readonly disable`, `steamos-devmode` changes, pacman installs, or reboots without explicit approval. Three installers need host `sudo`, and they ask for it: the Bluetooth fixes (`setup/bluetooth/install.sh`), hand tracking (`hands/run.sh install` and `caps`, which set ft-camd's file capabilities with `setcap`), and our own eye tracker's frame grabber (`gaze/tracker/install.sh`).
- Write only inside the repo, `/tmp`, and the container unless told otherwise. The installers are the exception: they write the user services, launchers, and the SteamVR driver into the home folder. The Bluetooth fixes and the eye tracker's frame grabber also install root-owned files and system services under `/etc` (`/etc/steamframe`, `/etc/frametop`, `/etc/systemd/system`). When an installer starts writing something new outside the repo, add it to `uninstall.sh` too: users uninstall with that script, not with each installer's `uninstall`.
+- Write only inside the repo, `/tmp`, and the container unless told otherwise. The installers are the exception: they write the user services, launchers, and the SteamVR driver into the home folder. The Bluetooth fixes and the eye tracker's frame grabber also install root-owned files and system services under `/etc` (`/etc/steamframe`, `/etc/frametop`, `/etc/systemd/system`).
 - Never copy `.netrc`, SSH keys, or Steam config off the Frame or into this repo.

 ## SteamOS updates
@@ -57,7 +57,6 @@ If you work in the desktop for long stretches, or leave the headset on a stand,
 | While carrying a screen, sweep its laser across your other controller's ring, then let go | Pins it to that wrist, at its size and distance, as you hold it when you let go; it shows while you see its front. Grab its bar to adjust it (it stays pinned); sweep across the ring again to take it off |
 | Set a screen to On your head (Frametop Display Settings, Visibility & pins) | Pins it to your head where it is, like a HUD. Grab its bar to move it; it stays on your head |
 | Meta+Shift+R in the desktop | Puts the screens back in their layout (also in the menu as Reset Screen Layout, and mappable to a mouse button) |
-| Meta+Alt+Tab, or Meta+Alt+Shift+Tab | Spins every screen and floating window around you together, like a lazy susan, so the next one on your right (or left) glides to straight ahead, with the pointer and typing going to it. Their arrangement stays the same: the room turns instead of you. Tap again to keep going; Meta+Shift+R puts the screens back. Pinned screens stay where they are |
 | Meta+Shift+H in the desktop | Hides or shows all screens (also in the menu as Hide/Show Screens, and mappable). The Visibility & pins tab of Frametop Display Settings can instead show them only with the dashboard open, or while you look at your wrist |
 | Tap Meta, on any keyboard | Opens the Steam menu in the SteamVR dashboard, or closes the dashboard, wherever you are. The desktop's launcher is still on the taskbar and Alt+F1. Change it in Frametop Input Settings (Keyboard page), where any key combination or modifier tap can do a Frametop or Steam action, open a profile, or run a command of your own |
 | Switch a screen to Hidden (Frametop Display Settings, Visibility & pins → Screens shown) | Hides just that screen until you switch it back, whatever the other visibility settings say; new windows that would open on it float instead |
@@ -171,22 +170,23 @@ Or by hand: `cd ~/frametop && git pull && ./install.sh`.

 ## Uninstall

-In a terminal on the headset, run:
-
 ```
-curl -fsSL https://deejanuz.github.io/frametop/uninstall.sh | bash
+./desktops.sh uninstall                # the launcher's Desktop entry goes back to the stock desktop
+./desktops.sh relay uninstall
+pointer/helper/run.sh uninstall
+power/run.sh uninstall
+pointer/driver/install.sh uninstall    # then restart SteamVR
+input-settings/install.sh uninstall
+display-settings/install.sh uninstall
+remote/install.sh uninstall
+setup/bluetooth/install.sh uninstall   # if you installed the Bluetooth fixes
+hands/run.sh uninstall                 # if you installed hand tracking by hand
+gaze/run.sh uninstall                  # if you installed the gaze service
+gaze/tracker/install.sh uninstall      # if you installed our own eye tracker's frame grabber
+gaze/probe/install.sh uninstall        # if you installed the gaze probe
 ```

-It works in two steps, so it never takes away the keyboard, mouse, or desktop you're using while it runs:
-
-1. It stops Frametop from starting. Launch a program → Desktop opens the stock desktop again, and Frametop's services, its SteamVR driver, its menu entries, and the system files of our eye tracker and the Bluetooth fixes are removed (those need your `sudo` password). Everything running now keeps running until you restart the headset, and it offers to restart it for you.
-2. After the restart, run the same command again. It deletes the code in `~/frametop`, and asks whether to delete your settings, any eye or hand recordings, and the build container (1–2 GB) too.
-
-To see what it would do without changing anything, add `-s -- --dry-run` after `bash`. If the code isn't in `~/frametop`, add `-s -- --dir <folder>`. From the repo, the same script is `./uninstall.sh`.
-
-Don't delete `~/frametop` by hand before you uninstall and restart: the desktop and the input relay run from it, and without it Launch a program → Desktop no longer opens anything. If you've already deleted it, the command above still works, since it doesn't need the repo.
-
-Unless you ask for them to go, your settings stay: `~/.config/frametop.conf`, `frametop-input.json` (button maps and key combinations), `frametop-layout.json` (the layout and profiles), `frametop-float.json`, and `frametop-remote/` in `~/.config`, the gaze calibration in `~/.local/state/frametop`, and the desktop's own Plasma setup in `~/.config/frametop`. A later install picks them up again.
+Your settings stay: `~/.config/frametop.conf`, `frametop-input.json` (button maps and key combinations), `frametop-layout.json` (the layout and profiles), `frametop-float.json`, and `frametop-remote/` in `~/.config`, and the gaze calibration in `~/.local/state/frametop/gaze`. So does the desktop's own Plasma setup, in `~/.config/frametop`. Delete them too for a clean slate.

 ## How it works

@@ -196,7 +196,6 @@ A Plasma session runs nested inside ft-screens (`screens/`), a small Wayland com
 | --- | --- |
 | `get.sh` | The one-line installer: picks stable or experimental, clones or updates the repo, and runs `install.sh`. |
 | `install.sh` | The one-step installer. Safe to re-run. |
-| `uninstall.sh` | The uninstaller: run it, restart the headset, and run it again. It doesn't need the rest of the repo. |
 | `desktops.sh` | Start, stop, and configure the desktop, and install the input relay. |
 | `screens/` | ft-screens, the compositor (wlroots and OpenVR). |
 | `session/` | The desktop session script and its config example. |
@@ -3,7 +3,7 @@ Type=Application
 Name=Reset Screen Layout
 GenericName=Put the VR desktop's screens back in their layout
 Comment=Float the screens and arrange them in the layout from Frametop Display Settings
-Exec=@REPO@/layout/ft-layout-reset
+Exec=@REPO@/layout/ft-layout apply
 Icon=view-restore
 Categories=Settings;
 Keywords=display;screen;layout;arrange;reset;steamvr;frametop;
@@ -3,7 +3,7 @@ Type=Application
 Name=Hide/Show Screens
 GenericName=Hide or show the VR desktop's screens
 Comment=Hide the screens (and SteamVR's laser) for a VR game; press again to bring them back
-Exec=@REPO@/layout/ft-hide-show
+Exec=@REPO@/layout/ft-layout toggle
 Icon=view-visible
 Categories=Settings;
 Keywords=display;screen;hide;show;steamvr;frametop;
@@ -1,6 +1,6 @@
 # Controller desktop click stability

-Trigger presses reach KDE immediately, but controller motion within 32 logical
+Trigger presses reach KDE immediately, but controller motion within 8 logical
 pixels of the press stays at that position until release. Releasing without a motion outside this
 zone delivers the click at the original position, even if the hand moved during
 release. Moving outside the zone begins a normal drag immediately; returning to
@@ -13,11 +13,11 @@ floating-app title-bar carrying are unaffected. Multi-button gestures keep their
 existing behavior. A motion onto another desktop monitor starts a drag;
 cross-monitor motion is not stabilized.

-CLI (runtime preferences, reset to 32 on desktop restart):
+CLI (runtime preferences, reset to 8 on desktop restart):

 ```sh
 input/ft-clickctl status
-input/ft-clickctl threshold 32
+input/ft-clickctl threshold 8
 input/ft-clickctl threshold 0  # disable without a restart
 ```

@@ -29,6 +29,6 @@ This is a separate contribution from desktop mouse/controller ownership. Its
 hardware validation must check small controls, intentional text selection,
 long presses, cross-monitor dragging and simultaneous mouse use. The existing
 renderer laser remains tracked; this change stabilizes desktop input rather
-than smoothing the visual laser. The default was 8 at first. That's about 0.2° on a 3.4 m wide 3440-pixel screen 2 m away, and clicking took a very still hand, so it's 32 (about 0.9°) since 2026-10-03.
+than smoothing the visual laser. Default threshold is a starting point to test.

 Run `scripts/test-controller-click.sh` for the isolated gesture-state tests.
@@ -38,7 +38,7 @@ The curved layout chains screens edge to edge, like monitors on a desk: the midd

 A resize handle has to be able to shrink a screen from any direction, so the dragged corner follows the laser along the screen's diagonal rather than taking the larger of its horizontal and vertical reach. Pushing and pulling a carried screen moves it along the line from your head, because the 3D mouse's virtual controller sits just in front of the bar, below the screen's centre, so the line from the device points mostly upward.

-Wherever ft-screens needs to know where a laser points (showing the controls, the resize tab, the roll knob), it uses the laser's own pose, the render model's `tip` component, rather than the controller's pose. On the Frame's controllers the tip points 40° below the pose's forward axis, so rays from the pose missed what the laser was actually on. The 3D mouse's virtual controller has no tip, and its laser runs along its pose. ft-screens reads the tip with `GetComponentState`: `GetComponentStateForDevicePath` without an input source handle fails for every component while a VR game runs, so in games the rays came from the pose, 40° too high.
+Wherever ft-screens needs to know where a laser points (showing the controls, the resize tab, the roll knob), it uses the laser's own pose, the render model's `tip` component, rather than the controller's pose. On the Frame's controllers the tip points 40° below the pose's forward axis, so rays from the pose missed what the laser was actually on. The 3D mouse's virtual controller has no tip, and its laser runs along its pose.

 `ComputeOverlayIntersection` ignores `SetOverlayIntersectionMask`, and a control can't be allowed to cover part of its screen, so the resize tab sits entirely outside the corner.

@@ -62,7 +62,7 @@ A profile's screen part is the custom arrangement under a name: each screen's po

 `IVRApplications::GetCurrentSceneProcessId()` is 0 when no game is running (the Frame's home environment isn't a scene app) and the game's process ID while one is. ft-screens checks it twice a second, turns the flag off while a game runs, and by default hides the screens unless the dashboard is open. Flatscreen games run inside Steam's gamescope overlay and aren't scene apps, which is why "only with the dashboard open" is offered as a controller setting.

-In a game, Frametop's panels work like SteamVR's own floating windows: point a controller at one and its laser comes on, point away and the game has the controllers again. ft-screens turns the flag on for a panel while a hand controller's laser pose meets it, its controls, or a floating window's popups. It finds that from the poses it already reads to show the controls, so SteamVR's laser doesn't have to be on first. Leaving takes a margin two control-sizes wide and 0.3 s, a drag or a held button keeps the flag on, and the keyboard, a single overlay, uses SteamVR's `ComputeOverlayIntersection`. The 3D mouse doesn't need any of this: it has its own laser mode.
+The reset button needs to work in a game, where the screens have the flag off. So ft-screens turns the flag on for that button's overlay alone while a hand controller aims within about one button's width of it, and off half a second after the aim leaves a zone twice as wide. ft-screens finds the aim from the controllers' laser poses, which it reads anyway to show the controls, so it doesn't need SteamVR's laser to be on first. The game loses the controllers only while you aim at the button.

 ## Floating windows

@@ -185,8 +185,6 @@ KWin renders with OpenGL through zink on Turnip, Vulkan on the same GPU vrcompos

 The nested session also runs the system's XDG autostart entries, being a KDE session. Discover's update notifier started `plasma-discover --mode update` in it (520 to 620 MB resident and about 9% of a core, plus `flatpak-system-helper` and AppStream downloads), and IBus started a daemon, the kimpanel panel and its GTK extension that nothing can use: KWin hands text input to the one input method it starts (`ft-textinput`), and the session drops `QT_IM_MODULE`, `GTK_IM_MODULE` and `XMODIFIERS`. The session hides both for this desktop only, with `Hidden=true` copies in its own autostart folder. The geoclue demo agent stays: it's what answers apps' location requests to Geoclue outside GNOME, and it costs nothing while idle. Orca's entry only starts in GNOME-family desktops.

-Plasma 6.2.5 keeps each panel on a screen number (`lastScreen` in `plasma-org.kde.plasma.desktop-appletsrc`), and the numbers rank the enabled outputs by priority, so 0 is the primary screen. A panel whose number is past the screen count gets no view, and Plasma never moves it: the remap it runs at every start only moves a panel whose number has no desktop, and this desktop keeps a desktop for every output it has seen, spares included. So the taskbar was lost when the number of screens went down, and once it was found saved on a spare output, number 8 of a desktop with three screens ([#18](https://github.com/DeeJanuz/frametop/issues/18)). Before Plasma starts, the session runs `session/fix-panels.py`, which moves any panel numbered past the screen count, with its system tray's containment, to screen 0, keeping its widgets and settings. A panel stays put when screen 0 already has one on that edge, and comes back by itself if the screens do. The file is backed up to `<file>.ft-bak` first. Plasma's scripting can't do this while it runs (`panel.screen` is read-only in 6.2.5), so a lost taskbar comes back at the desktop's next start. `scripts/doctor.sh` and `scripts/report.sh` list the panels and their screens.
-
 Remote desktop is a chain (krdp, then FreeRDP inside Xvnc) because nothing on SteamOS serves KWin over VNC directly. Kept connected all the time, it cost about a core with nobody watching: krdpserver 55 to 78% (it encodes H.264 in software with openh264: VA-API finds no driver for the Frame's GPU in the container), FreeRDP 16 to 27%, Xvnc 6 to 11%, and the bridge's layout check every 5 seconds another 4%. krdp creates its screencast session per RDP connection and drops it when the connection closes (`SessionController::onNewConnection` in krdp 6.7), so an idle krdpserver costs nothing and can stay up; only the RDP connection has to go. The bridge connects FreeRDP when a VNC client appears and disconnects 45 seconds after the last one leaves. Xvnc has no hook for its clients, so the bridge counts established connections to its port with `ss`, woken early by Xvnc's log output; looking with `ss` once a second cost about 0.9% of a core in bash, against about 0.1% this way. `Xvnc -inetd` from a systemd socket would start a server per connection and lose sharing between viewers. The layout check (`ft-layout remote-view`, which scans `/proc` for plasmashell and runs `kscreen-doctor -j`) now runs only while FreeRDP runs, and then only after `kwinoutputconfig.json` or `frametop-layout.json` changes, with one check a minute in case a change touched neither.

 Program names stay within 15 characters, because Linux truncates process names there and the scripts find programs with `pgrep -x` and `pkill -x`. That's why the prefix is `ft-`.
@@ -226,5 +224,6 @@ On the Frame, SteamVR is part of the OS image (`/opt/steamvr`, the `deckard-stea

 - A controller button that shows the screens during a game. Games own the controllers, so this needs SteamVR input actions for ft-screens.
 - Drawing KWin's cursor on the screens.
+- Plasma can lose its panels when the number of screens goes down, because they're saved against a screen that no longer exists. Removing `plasma-org.kde.plasma.desktop-appletsrc` and `plasmashellrc` from `~/.config/frametop` brings the default panels back.
 - Frame pacing and GPU cost with several busy screens haven't been measured.
 - Real standby on a stand, with rendering and tracking paused, not just the backlight off. SteamVR has no call for it, and its activity level follows the proximity sensor.
@@ -44,7 +44,7 @@ Every screen is an overlay named `frametop.screen.N` with five controls:
 - `.curve` bends the screen into a cylinder around you, using your current distance as the radius, or makes it flat again.
 - `.roll` rolls the screen when you drag it sideways, like a knob. It snaps level within 2.5°, and scrolling on it turns 5° per notch.
 - `.resize`, the tab on the bottom right corner, sets the width. Screens go down to 15 cm wide.
- `.reset`, left of the bar, puts every screen back in its layout around where you are now, like Meta+Shift+R (`ft-layout apply`).
+- `.reset`, left of the bar, puts every screen back in its layout around where you are now, like Meta+Shift+R (`ft-layout apply`). In a VR game, where the screens leave the controllers to the game, aiming a controller at it turns SteamVR's laser on for that button alone, so the trigger clicks it; the game gets the controllers back half a second after you aim away.

 The controls are sized from both the screen's width and its distance from you, follow the surface of a curved screen, and stay invisible until a laser or the 3D mouse's cursor lands on one or comes within about 1.5 times a button's size of it. While invisible they're still there, fully transparent, so SteamVR's laser can find them. They're translucent until a laser is on them, like SteamVR's own window controls.

@@ -62,7 +62,7 @@ The Visibility & pins tab of Frametop Display Settings decides when the screens
 In the last three modes the hotkey shows the screens anyway. A screen can also be hidden on its own (Screens shown on the same tab, or `ft-layout hide N`): it stays hidden whatever the mode or the hotkey says, until it's shown again there. Windows on it stay put, and a new window that would open on it floats instead (ft-floatd). Profiles use this to show only some screens. Two more settings on the same tab cover VR games, which ft-screens detects as SteamVR scene apps:

 - During VR games, the Always mode hides the screens unless the dashboard is open (the default), or leaves them up.
- Controllers on the screens. Visible screens can keep SteamVR's laser mouse on, so controllers work them with the dashboard closed, but that also takes the controllers away from a game. By default this is off while a VR game runs, and the 3D mouse or the dashboard works the screens. Pointing a controller at a screen, a floating window, or the keyboard still turns its laser on, like SteamVR's own floating windows, and pointing away gives the game the controllers back. The other choices are always on, or only with the dashboard open, which also suits flatscreen games since they aren't scene apps.
+- Controllers on the screens. Visible screens can keep SteamVR's laser mouse on, so controllers work them with the dashboard closed, but that also takes the controllers away from a game. By default this is off while a VR game runs, and the 3D mouse or the dashboard works the screens. The other choices are always on, or only with the dashboard open, which also suits flatscreen games since they aren't scene apps.

 Input from the lasers reaches KWin through ft-screens' own seat. Keys come from the input relay, from pass-through keyboards and any key a pointer device passes through. Typing follows your last click: after a click on a screen it goes to the desktop, even with the SteamVR dashboard open, and after a mouse click on any other panel (the dashboard, Steam, an app like Spotify) it goes there instead. While it goes to the desktop, the relay grabs pass-through keyboards so gamescope, which reads every keyboard itself, doesn't type them into the Steam app too. A program that watches every keyboard for a hotkey loses a grabbed one; with `SHARE_KEYS=1` in `~/.config/frametop.conf`, their keys also go to `@frametop_keys` for it. That's off by default, since any local process that binds the name first would get everything typed into the desktop. Hidden screens don't take typing.

@@ -134,7 +134,7 @@ A Kirigami app with a Python backend, in the Plasma menu under Settings. It runs
 - Buttons maps a pointer device's buttons. Choose Capture a button, press the button or key, then pick an action: a click, back, scroll, toggle dashboard, recenter, pointer on or off, head follow on or off, gaze pointer on or off, gaze precision, gaze drag, gaze quick check, faster or slower, reset the screen layout, hide or show the screens, open or close the keyboard, float a window in VR or put it back, put all floating windows back, pause or resume Frametop ([Pausing for VR games](#pausing-for-vr-games)), Open profile NAME (one per profile, [profiles.md](profiles.md)), pass the key through, or nothing. Devices with saved mappings are listed even while they're asleep.
 - Controllers maps the Frame controllers' buttons (every button but the system button) to the same actions, except passing a key through and the gaze actions: gaze mode is a mouse and keyboard feature ([gaze-controllers.md](gaze-controllers.md)). Capture a button and press it on a controller, or pick it from the list. The controllers aren't input devices on the host; only SteamVR sees them. So the pointer helper reads them with SteamVR input (`pointer/helper/vrbuttons.h`, `pointer/helper/actions/`) and sends presses to the relay (`vrbtn right/a 1`), which does the mapped action. The helper only takes the buttons that are mapped (the relay tells it with `vrbind`), at an overlay-global priority, and only while no game (scene application) runs, so games keep every button; with In games on (`controller_in_games`), a mapped button is taken from games too. That needs SteamVR's "Enable global input from overlays (Experimental)" setting (`steamvr/globalActionSetPriority`), which the page's Global input switch turns on and off. Mappings are saved as `controller_buttons` in `~/.config/frametop-input.json`.
 - Game optimization has the pause for VR games: its state with Pause now or Resume, whether VR games pause Frametop by themselves, the controller gesture (one or two buttons, pressed once or twice; one button always takes two presses), what happens to the desktop, and the sound. They're saved as `pause_auto`, `pause_gesture`, `pause_desktop`, and `pause_sound` in `~/.config/frametop-input.json`. See [Pausing for VR games](#pausing-for-vr-games).
- Keyboard sets when Frametop's keyboard opens: whenever a text field is selected; only while no pass-through keyboard is connected (the default; keyboards other programs make through uinput, like frame-voice's, don't count); only with a mouse or controller button mapped to Open/close keyboard; or never, which turns the button off too. Keep it open (on by default, `vr_keyboard_persist`) leaves it open after the text field loses focus. The mode is saved as `vr_keyboard` in `~/.config/frametop-input.json`, and the page lists the keyboards that count as connected. Its Key combinations section maps modifiers plus a key, or one modifier tapped on its own, on any keyboard, to any action but passing a key through or nothing, or to Run a command…: a command line the input relay runs with `sh -c` when you press the keys (`command:CMD`). The command runs as the relay's user service, outside the desktop's session, with `layout/`, `float/` and `steam/` on its `PATH` (so `ft-layout use Work` or `ft-float launch org.kde.dolphin` work as they are), and its output goes to the relay's journal. The gaze clicks (Gaze left click and Gaze right click) only go on key combinations. The defaults are a Meta tap (open the Steam menu, or close the dashboard), Meta+J (gaze left click), Meta+K (gaze right click), Meta+Shift+F (float window in VR or put it back), and Meta+Alt+Tab and Meta+Alt+Shift+Tab (spin the panels: every screen and floating window turns about your head, so the next one on the right or left comes to the front; ft-screens' `spin next|prev|<degrees>`); remove them or add others there. A tap is a press and release with no other key, mouse button, or scroll in between; a bound one sends the desktop F24 before the release, so Plasma's launcher doesn't open on it. The combination's last key isn't typed, and the modifiers still reach the app; while typing goes to Steam rather than the desktop, keyboards aren't grabbed, so Steam or the game sees the keys too. They're saved as `key_bindings` in the same file; a file with its own list, even an empty one, gets no defaults.
+- Keyboard sets when Frametop's keyboard opens: whenever a text field is selected; only while no pass-through keyboard is connected (the default; keyboards other programs make through uinput, like frame-voice's, don't count); only with a mouse or controller button mapped to Open/close keyboard; or never, which turns the button off too. Keep it open (on by default, `vr_keyboard_persist`) leaves it open after the text field loses focus. The mode is saved as `vr_keyboard` in `~/.config/frametop-input.json`, and the page lists the keyboards that count as connected. Its Key combinations section maps modifiers plus a key, or one modifier tapped on its own, on any keyboard, to any action but passing a key through or nothing, or to Run a command…: a command line the input relay runs with `sh -c` when you press the keys (`command:CMD`). The command runs as the relay's user service, outside the desktop's session, with `layout/`, `float/` and `steam/` on its `PATH` (so `ft-layout use Work` or `ft-float launch org.kde.dolphin` work as they are), and its output goes to the relay's journal. The gaze clicks (Gaze left click and Gaze right click) only go on key combinations. The defaults are a Meta tap (open the Steam menu, or close the dashboard), Meta+J (gaze left click), Meta+K (gaze right click), and Meta+Shift+F (float window in VR or put it back); remove them or add others there. A tap is a press and release with no other key, mouse button, or scroll in between; a bound one sends the desktop F24 before the release, so Plasma's launcher doesn't open on it. The combination's last key isn't typed, and the modifiers still reach the app; while typing goes to Steam rather than the desktop, keyboards aren't grabbed, so Steam or the game sees the keys too. They're saved as `key_bindings` in the same file; a file with its own list, even an empty one, gets no defaults.
 - Pointer has a Head follow switch and sliders for the pointer settings, which apply immediately, and a Recenter button.
 - Ignored panels lists the SteamVR overlays that are showing, grouped by app (the first two parts of the overlay key, such as `sasaken.frame-perf-overlay`), from the pointer helper (`overlays`). Tick a panel, or Ignore the whole app, and the pointer passes through it to what's behind. It's for panels you only look at, like a performance overlay that follows your view. The list is saved as `POINTER_IGNORE` in `~/.config/frametop.conf`: comma-separated overlay keys, where a shell pattern like `vendor.app*` covers a whole app, including panels it opens later. The helper reloads at once. Frametop's own screens aren't listed, and entries for apps that aren't open are listed below, to remove.
 - Gaze has the gaze pointer switch (on now and from now on; a mapped button toggles it until the helper restarts), what the mouse's left button and movement do, the gaze dot, the eye tracker and eye bias, the gaze mode sliders, the gaze service's state (headset, samples per second, how often the tracker is losing each eye, the calibration, the nudges learned), and Quick check, Calibrate, and Check headset fit (each in a panel in the headset), Reload calibration, and Forget nudges. The gaze probe, a development tool, is in the page's overflow menu.
@@ -378,17 +378,6 @@ function run(c) {
        case "activate":
            if (w) workspace.activeWindow = w;
            break;
-        case "activate-output": {  // the top window on that output (a spin brought it to the front)
-            const order = workspace.stackingOrder;
-            for (let i = order.length - 1; i >= 0; --i) {
-                const o = order[i];
-                if (o.deleted || o.minimized || o.hidden || !o.managed || !o.output) continue;
-                if (o.output.name !== c.output || !o.normalWindow || o.popupWindow) continue;
-                workspace.activeWindow = o;
-                break;
-            }
-            break;
-        }
        case "minimize":
            if (w) w.minimized = c.on;
            break;
@@ -18,8 +18,6 @@ command-line side). Replies go to the sender:
  ("float pointer" is the float key: the window under the pointer, else the active one,
  floated or docked; the input relay sends it for float_toggle, and "dock all" for dock_all)
  dock N | close N | resize N W H | scale N STEPS                      (ft-screens, N = its screen)
-  front N   (ft-screens: a spin brought panel N to the front: make its window, or the top one
-            on a screen, KWin's active window)

 Spare outputs are WL-<screens> .. WL-<screens + slots - 1>. A floating window's output is its
 frame plus a margin on each side (FLOAT_MARGIN pixels), so menus have room; the panel shows
@@ -1065,13 +1063,6 @@ class Daemon:
            for f in list(self.floats.values()):
                self.dock(f)
            return "ok"
-        if cmd == "front" and len(rest) == 1 and rest[0].isdigit():
-            f = self.by_panel(int(rest[0]))
-            if f:
-                self.command(cmd="activate", id=f.id)
-            else:  # a screen: its output is WL-<N - 1>
-                self.command(cmd="activate-output", output=f"WL-{int(rest[0]) - 1}")
-            return "ok"
        if cmd in ("dock", "close", "resize", "scale") and rest and rest[0].isdigit():
            f = self.by_panel(int(rest[0]))
            if not f:
@@ -1,68 +0,0 @@
---
-title: Install the Frametop Hand Recorder
---
-
-# Install the Frametop Hand Recorder
-
-The Hand Recorder records your hands with the Steam Frame's tracking cameras for Frametop's open hand dataset ([DeeJanuz/frametop-hands](https://huggingface.co/datasets/DeeJanuz/frametop-hands) on Hugging Face). These are the Konsole commands to install it.
-
-> **Known issue (October 5, 2026):** the recorder currently works only on headsets with the Arcturus color passthrough module attached. Without the module, the camera check stops with "Not all of the headset's tracking cameras are running (ft-camd publishes only 2 of 4 mono cameras ...)", and restarting SteamVR or the headset doesn't help. A fix for headsets without the module will be published within 24 hours (by October 6). Once it's out, run the commands under [Update](#update).
-
-Join the [Frametop Discord](https://discord.gg/W3X9f7z3Bc) for questions and help with recording.
-
-For now the recorder runs inside Frametop's desktop, so these steps install Frametop first. A standalone recorder that runs from the SteamVR dashboard without Frametop is planned.
-
-## Before you start
-
- You must be 18 or older, and for now you can't take part if you live in Illinois, Texas or Washington (USA). The [consent text](https://github.com/DeeJanuz/frametop/blob/main/hands/rec/CONSENT.md) explains what's recorded and what you agree to. The recorder shows it again before your first session.
- You need a Steam Frame on the stable SteamOS release (not the beta), an internet connection, and a keyboard (Bluetooth, or the on-screen one).
- You need a `sudo` password. If you've never set one, run `passwd` in Konsole first.
- Recordings are several gigabytes per round, and uploading one needs about the same again free while it runs. `df -h ~` shows your free space.
-
-## Open Konsole
-
-1. In the launcher, choose Launch a program → Desktop.
-2. In the application menu, open System → Konsole.
-
-## 1. Install Frametop
-
-```
-curl -fsSL https://deejanuz.github.io/frametop/get.sh | bash -s -- --stable
-```
-
-This clones Frametop into `~/frametop` and runs its installer. The first run downloads 1–2 GB. The installer asks a few questions (gaze mode, the eye tracker, the Bluetooth fixes); the defaults are fine. At the end SteamVR restarts, which closes Konsole. If Frametop is already installed, this updates it.
-
-## 2. Install the Hand Recorder
-
-After SteamVR restarts, choose Launch a program → Desktop again, open Konsole, and run:
-
-```
-~/frametop/hands/rec/install.sh
-```
-
-This builds the camera broker, the hand tracker and the headset panel (the first build takes a few minutes), asks for your `sudo` password once to let the camera broker read the cameras, and adds Frametop Hand Recorder to the application menu.
-
-## 3. Record
-
-Open Frametop Hand Recorder from the desktop's application menu. It walks you through the consent text, a short checklist, the recording, a review of what you recorded, and the upload to Hugging Face. Nothing leaves the headset until you press Upload.
-
-## Update
-
-```
-curl -fsSL https://deejanuz.github.io/frametop/get.sh | bash -s -- --stable
-~/frametop/hands/rec/install.sh
-```
-
-Run the second command after SteamVR has restarted, as in the install.
-
-## Uninstall
-
-```
-~/frametop/hands/rec/install.sh uninstall
-```
-
-This removes the menu entry. Your recordings stay in `~/.local/share/frametop/hands/contrib`; delete that folder to remove them. To remove Frametop as well, follow [Uninstall](https://github.com/DeeJanuz/frametop#uninstall) in the README.
-
-## Help
-
-Ask in the [Frametop Discord](https://discord.gg/W3X9f7z3Bc), the [Frametop issues](https://github.com/DeeJanuz/frametop/issues), or the dataset's [discussion page](https://huggingface.co/datasets/DeeJanuz/frametop-hands/discussions). All three are public.
@@ -56,19 +56,13 @@ ANSI = re.compile(r"\x1b\[[0-9;]*m")
 STAMP = re.compile(r"^\w{3} \w{3} \d{2} \d{4} (\d{2}:\d{2}:\d{2})\.\d+ (\w+): ?(.*)$")
 # Lines worth reading; anything else is skipped before the regexes (the log grows by MBs a day).
 KEYS = ("FPGA", "VCINT", "Created", "TrackingCameraInit", "Closing tracking camera", "Streaming",
-        "systemd suspend", "systemd resume", "XRService logging to", "Exiting XRService", "ISP ")
-# XRService's numbering of its tracking cameras (the TrackingCameraInit index): ft-hands names
-# them this way too (track/main.cpp, cameras_from_xrservice_log).
-NAMES = ("slam_left", "slam_right", "upper_left", "upper_right")
+        "systemd suspend", "systemd resume", "XRService logging to", "Exiting XRService")
 RE_PASSTHRU = re.compile(r"Passthrough connected but FPGA is (\S+) - loading VCINT")
 RE_INTERLEAVE = re.compile(r"Upper cameras FPGA interleaving support: (\d)")
 RE_TASKS = re.compile(r"Created (\d+) tasks \((\d+) tracking, (\d+) passthrough\)")
 RE_INIT = re.compile(r"TrackingCameraInit: index: (\d+)\. video device: /dev/video(\d+)")
 RE_STREAM = re.compile(r"Streaming resumed \(FPGA: (\S+), VC interleaving: (\w+)\)")
 RE_STATE = re.compile(r"FPGA state check: (\S+)")
-# Without the colour module XRService runs the side cameras through the ISP, as NV12 on other
-# capture pipes (vfe0 and vfe1), and the upper pair on vfe3 and vfe4.
-RE_ISP = re.compile(r"ISP (enabled|disabled) for tracking cameras")


 class LogState:
@@ -91,7 +85,7 @@ class LogState:
    def _new_episode(self, t):
        self.closed = False
        self.episode = {"start": t, "fpga_before": "", "vcint": "", "interleave": None, "tasks": None,
-                        "inits": {}, "stream": "", "isp": None, "failure": "", "evidence": []}
+                        "inits": {}, "stream": "", "failure": "", "evidence": []}
        if self.closed_at:
            self.episode["evidence"].append(self.closed_at)

@@ -152,12 +146,6 @@ class LogState:
            ep["interleave"] = int(m.group(1))
            ep["evidence"].append(short)
            return
-        m = RE_ISP.search(text)
-        if m:
-            ep = self._ep(t)
-            ep["isp"] = m.group(1) == "enabled"
-            ep["evidence"].append(short)
-            return
        m = RE_TASKS.search(text)
        if m:
            ep = self._ep(t)
@@ -196,12 +184,6 @@ class LogState:
        got = tuple(self.nodes[i] for i in (2, 3) if i in self.nodes)
        return got if len(got) == 2 else UPPER_NODES

-    def camera_map(self):
-        """{calibration name: /dev/videoN's N} from the latest camera start's TrackingCameraInit
-        lines (the whole log's when that start has none yet)."""
-        inits = (self.episode or {}).get("inits") or self.nodes
-        return {NAMES[i]: node for i, node in sorted(inits.items()) if 0 <= i < len(NAMES)}
-
    def tracking_nodes(self):
        got = tuple(self.nodes[i] for i in range(TRACKING) if i in self.nodes)
        return got if len(got) == TRACKING else SIDE_NODES + UPPER_NODES
@@ -371,9 +353,7 @@ def check(log=None, proc=True, ring=True, ring_path=None):
        status, reason = "unknown", "no XRService log in %s" % LOG_DIR
    out = {"log": path, "xrservice": None, "ring": None,
           "episode": state.snapshot()["episode"] if state else {},
-           "failure": state.snapshot()["failure"] if state else "",
-           "map": {name: {"node": n, "pipe": pipe_name(n)} for name, n in state.camera_map().items()} if state else {},
-           "ring_missing": []}
+           "failure": state.snapshot()["failure"] if state else ""}

    if proc:
        if pid is None:
@@ -409,30 +389,13 @@ def check(log=None, proc=True, ring=True, ring_path=None):
            evidence.append("ft-camd (pid %d, %s): %d mono cameras: %s" % (
                r["writer_pid"], "running" if r["alive"] else "stale ring", len(r["mono"]), names))
            if r["alive"] and len(r["mono"]) < TRACKING and status == "ok":
-                have = {c["node"] for c in r["mono"]}
-                want = state.tracking_nodes() if state else SIDE_NODES + UPPER_NODES
-                out["ring_missing"] = [n for n in want if n not in have]
-                status, reason = "degraded", ("ft-camd publishes only %d of %d mono cameras, missing %s" % (
-                    len(r["mono"]), TRACKING, " ".join("video%d" % n for n in out["ring_missing"]) or "?"))
+                status, reason = "degraded", ("ft-camd publishes only %d of %d mono cameras (it started while "
+                                              "they were missing: restart it)" % (len(r["mono"]), TRACKING))
    out.update(status=status, reason=reason, evidence=evidence,
               summary="ok" if status == "ok" else "%s: %s" % (status, reason))
    return out


-def pipe_name(node):
-    """The capture pipe behind /dev/videoN (msm_vfe3_video0 and so on), or ""."""
-    try:
-        with open("/sys/class/video4linux/video%d/name" % node) as f:
-            return f.read().strip()
-    except OSError:
-        return ""
-
-
-def is_ring_short(result):
-    """XRService runs all the tracking cameras, but ft-camd doesn't publish them all."""
-    return bool(result) and result.get("status") == "degraded" and bool(result.get("ring_missing"))
-
-
 def is_vcint_failure(result):
    return bool(result) and result.get("status") == "degraded" and result.get("reason") == VCINT_REASON

@@ -379,15 +379,9 @@ static bool resolve_block(cam_t *c)
    return true;
 }

-/*
- * Through the ISP (no colour module), the near-black exposures come out all zeros,
- * the same every time, so their dequeues change no buffer and get no votes. Such
- * an index is left unmapped (slot -1): on_frame counts its frames as dark without
- * reading them. Most of a camera's indices silent means it isn't streaming yet.
- */
 static bool resolve_each(cam_t *c)
 {
-    int depth = c->maxindex + 1, silent = 0;
+    int depth = c->maxindex + 1;
    bool taken[MAX_SLOTS] = { false };

    for (int i = 0; i < depth; i++) {
@@ -402,12 +396,6 @@ static bool resolve_each(cam_t *c)
            }
        }

-        if (c->nobs[i] >= 3 && v1 <= 0.2 * c->nobs[i]) {
-            c->slot_of[i] = -1;
-            silent++;
-            continue;
-        }
-
        if (c->nobs[i] < 3 || best < 0 || taken[best] || v1 < 0.8 * c->nobs[i] || v2 > 0.3 * c->nobs[i])
            return false;

@@ -415,14 +403,9 @@ static bool resolve_each(cam_t *c)
        c->slot_of[i] = best;
    }

-    if (silent * 2 > depth)
-        return false;
-
    printf("%s: queue depth %d, buffers mapped one by one:", c->slug, depth);
    for (int i = 0; i < depth; i++)
-        c->slot_of[i] < 0 ? printf(" -") : printf(" %d", c->slot_of[i]);
-    if (silent)
-        printf(" (- : %d indices whose frames are all zeros, skipped as dark)", silent);
+        printf(" %d", c->slot_of[i]);
    printf("\n");
    return true;
 }
@@ -694,12 +677,6 @@ static void on_frame(cam_t *c, int64_t index, uint32_t seq, uint64_t ts, uint64_

    int slot = c->slot_of[index];

-    if (slot < 0) {     /* an index whose frames are all zeros (resolve_each): a dark one */
-        c->dark++;
-        c->rc->dropped++;
-        return;
-    }
-
    /* color runs at 60 fps: skip frames early enough that the asked rate holds, before any sync */
    if (c->color && color_fps > 0 && evtime - c->last_pub_ns < (uint64_t)(1e9 / color_fps) - 3000000) {
        c->paced++;
@@ -544,26 +544,22 @@ static void probe_cameras(xr_state_t *st)
 /*
 * qcom-camss can report bytesperline as the visible width while the VFE
 * writes a larger aligned pitch. sizeimage is right, so derive the pitch.
- * For NV12, plane 0 normally holds the chroma rows after the luma (the side
- * cameras through the ISP: 1056 wide, 1152 bytes a row); if it's too small for
- * that, it holds the luma alone.
 */
 unsigned xr_camera_stride(const xr_camera_t *c)
 {
    if (!c->height || !c->planesize[0])
        return c->bytesperline ? c->bytesperline : c->width;

-    bool yuv = c->pixfmt == V4L2_PIX_FMT_NV12 || c->pixfmt == V4L2_PIX_FMT_NV21;
-    unsigned s = (unsigned)((double)c->planesize[0] / ((double)c->height * (yuv ? 1.5 : 1.0)));
+    double bpp = 1.0;
+
+    if (c->pixfmt == V4L2_PIX_FMT_NV12 || c->pixfmt == V4L2_PIX_FMT_NV21)
+        bpp = 1.5;
+
+    unsigned s = (unsigned)((double)c->planesize[0] / ((double)c->height * bpp));

    if (s >= c->width && s <= c->width * 4)
        return s;

-    s = (unsigned)(c->planesize[0] / c->height);
-
-    if (yuv && s >= c->width && s <= c->width * 4)
-        return s;
-
    return c->bytesperline ? c->bytesperline : c->width;
 }

@@ -595,20 +591,7 @@ void xr_camera_layout(const xr_camera_t *c, xr_layout_t *l)
    l->pitch = xr_camera_stride(c);
    l->width = c->width < l->pitch ? c->width : l->pitch;

-    /*
-     * Without the colour module, XRService runs the side cameras through the
-     * ISP ("ISP enabled for tracking cameras (main VFE available)" in its log),
-     * and they come out NV12. They're mono sensors, so the luma is the image.
-     */
-    bool yuv = c->pixfmt == V4L2_PIX_FMT_NV12 || c->pixfmt == V4L2_PIX_FMT_NV21;
-
-    if (yuv && c->role && !strcmp(c->role, "tracking")) {
-        l->fmt  = XR_FMT_GREY8;
-        l->rows = c->height;
-        return;
-    }
-
-    if (yuv) {
+    if (c->pixfmt == V4L2_PIX_FMT_NV12 || c->pixfmt == V4L2_PIX_FMT_NV21) {
        l->fmt  = XR_FMT_NV12;
        l->rows = c->height + c->height / 2;
    } else {
@@ -457,12 +457,11 @@ class Backend(QObject):
        """Start stays off: the check found the cameras degraded (unless --ignore-cameras)."""
        return not self._ignore_cameras and self._camera.get("status") == "degraded"

-    def _check_now(self, repair=False):
-        """repair (off this thread only: it may restart ft-camd, up to 15 s): see session.camera_check."""
+    def _check_now(self):
        mod = self._runner()
        if not mod or self._session_options.get("dry_run"):
            return {"status": "unknown", "summary": "not checked (dry run)", "reason": "dry run", "evidence": []}
-        return mod.camera_check(repair=repair)
+        return mod.camera_check()

    @Slot()
    def checkCameras(self):
@@ -471,7 +470,7 @@ class Backend(QObject):
            return
        self._camera_busy = True
        self.cameraChanged.emit()
-        self._thread(lambda: self._cameraArrived.emit(self._check_now(repair=True)))
+        self._thread(lambda: self._cameraArrived.emit(self._check_now()))

    def _on_camera(self, result):
        self._camera = result
@@ -500,7 +499,7 @@ class Backend(QObject):
                end = time.monotonic() + RECHECK_FOR_S
                time.sleep(RECHECK_S * 2)
                while time.monotonic() < end:
-                    result = self._check_now(repair=True)
+                    result = self._check_now()
                    # Done once a new XRService (a new log) has opened its cameras, ok or not.
                    if result.get("status") in ("ok", "degraded") and result.get("log") != before:
                        break
@@ -1153,33 +1153,11 @@ def _steamvr_version():
    return ""


-_camd_restarted = set()   # ft-camd pids camera_check(repair=True) has restarted: once each
-
-
-def _unit_pid(unit):
-    r = subprocess.run(host_command("systemctl", "--user", "show", "-p", "MainPID", "--value", unit),
-                       capture_output=True, text=True, timeout=30)
-    try:
-        return int(r.stdout.strip() or 0)
-    except ValueError:
-        return 0
-
-
-def camera_check(repair=False):
+def camera_check():
    """camcheck.check() (the XRService log, its open cameras where readable, ft-camd's ring);
-    never raises: a failure is "unknown". repair (the window, never during a session): when
-    XRService runs every tracking camera but the recorder's own ft-camd doesn't publish them all
-    (it started while some were missing), restart it, once per ft-camd, and check again."""
+    never raises: a failure is "unknown"."""
    try:
-        r = camcheck.check()
-        pid = (r.get("ring") or {}).get("writer_pid")
-        if repair and camcheck.is_ring_short(r) and pid not in _camd_restarted and _unit_pid(CAMD_UNIT) == pid:
-            _camd_restarted.add(pid)
-            stop_unit(CAMD_UNIT)
-            start_camd()
-            r = camcheck.check()
-            r["evidence"].append("restarted ft-camd (pid %d) because it published only some of the cameras" % pid)
-        return r
+        return camcheck.check()
    except Exception as e:
        return {"status": "unknown", "summary": "unknown: the camera check failed (%s)" % e,
                "reason": str(e), "evidence": []}
@@ -1191,10 +1169,6 @@ def camera_text(result):
        return ""
    if camcheck.is_vcint_failure(result):
        return camcheck.USER_TEXT
-    if camcheck.is_ring_short(result):
-        return ("The headset's tracking cameras are all running, but the recorder can't read some of them (%s). "
-                "Close the Hand Recorder, run ~/frametop/hands/rec/install.sh again, and open it again. If that "
-                "doesn't help, ask in the Frametop Discord." % result.get("reason", ""))
    return ("Not all of the headset's tracking cameras are running (%s). Restart SteamVR, or restart the "
            "headset if that doesn't fix it." % result.get("reason", ""))

@@ -1477,10 +1451,6 @@ class Session:
        cam = self._status.get("camera")
        if cam:
            self._session_json["camera"] = {"status": cam.get("status"), "reason": cam.get("reason", "")}
-            # which device each calibrated camera was (XRService's numbering) and whether XRService
-            # ran the side cameras through the ISP (no colour module): to check the names later
-            self._session_json["device"]["camera_map"] = cam.get("map") or {}
-            self._session_json["device"]["isp"] = (cam.get("episode") or {}).get("isp")
        if self.dry_run:
            self._session_json["dry_run"] = True
        if self.speed != 1:
@@ -66,22 +66,6 @@ RESUME_OK = [L("12:30:00", "[SystemdInhibitor] Received systemd resume notificat
             for i, n in enumerate((9, 13, 6, 7))] + \
            [L("12:30:02", "[DeckardCaptureSource] Streaming resumed (FPGA: VCINT, VC interleaving: enabled)")]
 EXIT = [L("13:00:00", "XRService - main thread exiting"), L("13:00:00", "Exiting XRService")]
-# The colour module unplugged while SteamVR runs (2026-10-05 12:42): XRService reopens the
-# cameras with the side pair through the ISP on vfe0 and vfe1 (NV12); VCINT stays loaded, so the
-# upper pair stays on vfe2.
-UNPLUG = [L("12:42:25", "Received passthrough camera connection event (connected=0)"),
-          L("12:42:25", "[DeckardCaptureSource] Closing tracking camera interfaces camerasToUse: 1111"),
-          L("12:42:26", "FPGA state check: VCINT (register value: 0x00021211)"),
-          L("12:42:26", "Upper cameras FPGA interleaving support: 1 (Driver features available = 1 | VCINT loaded = 1)"),
-          L("12:42:26", "[buildMediaCtlSetupTasks] ISP enabled for tracking cameras (main VFE available)"),
-          L("12:42:26", "[buildMediaCtlSetupTasks] Created 4 tasks (4 tracking, 0 passthrough)")] + \
-         [L("12:42:26", "TrackingCameraInit: index: %d. video device: /dev/video%d. v4l subdevice: x" % (i, n))
-          for i, n in enumerate((0, 3, 6, 7))]
-# Started without the module (FrameEyeCameraFeed's layout): the upper pair on vfe3 and vfe4.
-NO_MODULE = [L("10:00:02", "[buildMediaCtlSetupTasks] ISP enabled for tracking cameras (main VFE available)"),
-             L("10:00:02", "[buildMediaCtlSetupTasks] Created 4 tasks (4 tracking, 0 passthrough)")] + \
-            [L("10:00:03", "TrackingCameraInit: index: %d. video device: /dev/video%d. v4l subdevice: x" % (i, n))
-             for i, n in enumerate((0, 3, 9, 13))]


 def state(lines):
@@ -144,23 +128,6 @@ class SyntheticLogs(unittest.TestCase):
        self.assertEqual(status, "degraded")
        self.assertEqual(reason, "only 2 of 4 tracking cameras running")

-    def test_camera_map_with_module(self):
-        st = state(START + GOOD_OPEN)
-        self.assertEqual(st.camera_map(), {"slam_left": 9, "slam_right": 13, "upper_left": 6, "upper_right": 7})
-
-    def test_module_unplugged(self):
-        st = state(START + GOOD_OPEN + UNPLUG)
-        self.assertEqual(st.verdict()[0], "ok")
-        self.assertIs(st.episode["isp"], True)
-        self.assertEqual(st.camera_map(), {"slam_left": 0, "slam_right": 3, "upper_left": 6, "upper_right": 7})
-        self.assertEqual(st.tracking_nodes(), (0, 3, 6, 7))
-
-    def test_started_without_module(self):
-        st = state(START + NO_MODULE)
-        self.assertEqual(st.verdict()[0], "ok")
-        self.assertEqual(st.camera_map(), {"slam_left": 0, "slam_right": 3, "upper_left": 9, "upper_right": 13})
-        self.assertEqual(st.upper_nodes(), (9, 13))
-
    def test_exited_and_empty(self):
        self.assertEqual(state(START + GOOD_OPEN + EXIT).verdict()[0], "unknown")
        self.assertEqual(state([]).verdict()[0], "unknown")
@@ -256,9 +223,9 @@ class RealLog(unittest.TestCase):
        self.assertEqual(out.getvalue().split("\n")[0], "ok")


-def make_ring(path, mono_names, alive=True, nodes=None):
+def make_ring(path, mono_names, alive=True):
    """A ring header as ft-camd writes it (camd/fhring.h), no frames."""
-    cams = [(b"og01a1b", n.encode(), nodes[i] if nodes else 9 + i) for i, n in enumerate(mono_names)]
+    cams = [(b"og01a1b", n.encode(), 9 + i) for i, n in enumerate(mono_names)]
    hb = time.clock_gettime_ns(time.CLOCK_MONOTONIC) if alive else 1
    data = bytearray(camcheck.RING_HDR.pack(b"FHRING01", 1, 0, len(cams), 0, 0, 4242, 0))
    struct.pack_into("<Q", data, 40, hb)
@@ -285,19 +252,6 @@ class Ring(unittest.TestCase):
        self.assertEqual(r["status"], "degraded")
        self.assertIn("ft-camd publishes only 2 of 4", r["reason"])

-    def test_ring_missing_the_side_cameras(self):
-        # an ft-camd from before NV12 support, without the colour module: only the upper pair
-        with open(self.log, "w") as f:
-            f.write("\n".join(START + NO_MODULE) + "\n")
-        make_ring(self.ring, ["og0ve10_5-003e_video9", "og0ve10_5-0060_video13"], nodes=[9, 13])
-        r = camcheck.check(log=self.log, proc=False, ring_path=self.ring)
-        self.assertEqual(r["status"], "degraded")
-        self.assertEqual(r["ring_missing"], [0, 3])
-        self.assertIn("missing video0 video3", r["reason"])
-        self.assertTrue(camcheck.is_ring_short(r))
-        self.assertFalse(camcheck.is_vcint_failure(r))
-        self.assertEqual(r["map"]["slam_left"]["node"], 0)
-
    def test_four_cameras_in_ring(self):
        make_ring(self.ring, ["a_video9", "b_video13", "c_video6", "d_video7", "a_video9_dk"])
        r = camcheck.check(log=self.log, proc=False, ring_path=self.ring)
@@ -34,28 +34,8 @@ from tools.show_set import index, read_set  # noqa: E402
 from tools import calib  # noqa: E402


-PIPES = {'msm_vfe3_video0': 'slam_left', 'msm_vfe4_video0': 'slam_right',    # with the colour module
+PIPES = {'msm_vfe3_video0': 'slam_left', 'msm_vfe4_video0': 'slam_right',    # as ft-hands maps them
         'msm_vfe2_video0': 'upper_left', 'msm_vfe2_video1': 'upper_right'}
-
-
-def ring_names():
-    """{/dev/videoN's N: calibration name} as ft-hands names them: by XRService's log
-    (camcheck.py), else by capture pipe (PIPES)."""
-    import camcheck
-    try:
-        by_log = {node: name for name, node in camcheck.read_log(camcheck.newest_log()).camera_map().items()}
-    except (OSError, ValueError):
-        by_log = {}
-    if by_log:
-        return by_log
-    out = {}
-    for path in os.listdir('/sys/class/video4linux'):
-        if path.startswith('video'):
-            with open('/sys/class/video4linux/%s/name' % path) as f:
-                name = PIPES.get(f.read().strip())
-            if name:
-                out[int(path[5:])] = name
-    return out
 PAIRS = {'side': ('slam_left', 'slam_right'), 'upper': ('upper_left', 'upper_right')}


@@ -120,9 +100,8 @@ def live_pairs(count, names=PAIRS['side']):
    if not ring.alive():
        sys.exit('ft-camd isn\'t running (no heartbeat)')
    cams = {}
-    names_of = ring_names()
    for c in ring.cams:
-        name = names_of.get(c.node)
+        name = PIPES.get(open('/sys/class/video4linux/video%d/name' % c.node).read().strip())
        if name and not c.name.endswith('-dark'):
            cams[name] = c
    for k in range(count):
@@ -63,34 +63,7 @@ namespace {

 volatile std::sig_atomic_t g_stop = 0, g_record = 0;

-// Which calibrated camera each video device carries. XRService numbers its tracking cameras
-// (index 0 to 3: slam_left, slam_right, upper_left, upper_right) and logs the device each one
-// opened ("TrackingCameraInit: index: 0. video device: /dev/video9"). The devices depend on
-// the colour module: with it, the side cameras are on vfe3 and vfe4 and the upper pair on
-// vfe2; without it, XRService runs the side cameras through the ISP on vfe0 and vfe1, and the
-// upper pair on vfe3 and vfe4. So the running XRService's log decides; when it can't be read,
-// the capture pipes as they are with the module. {} if the log has no cameras.
-std::map<int, std::string> cameras_from_xrservice_log() {
-    static const char *const names[] = {"slam_left", "slam_right", "upper_left", "upper_right"};
-    const char *home = std::getenv("HOME");
-    std::ifstream in(std::string(home ? home : "") + "/.local/share/Steam/logs/xrservice.txt");
-    const std::string key = "TrackingCameraInit: index: ";
-    std::map<int, int> node_of;   // index -> N of /dev/videoN, from the latest camera start
-    std::string line;
-    while (std::getline(in, line)) {
-        if (line.find("XRService logging to") != std::string::npos) node_of.clear();
-        const auto at = line.find(key);
-        int index = -1, node = -1;
-        if (at != std::string::npos &&
-            std::sscanf(line.c_str() + at + key.size(), "%d. video device: /dev/video%d", &index, &node) == 2 &&
-            index >= 0 && index < 4)
-            node_of[index] = node;
-    }
-    std::map<int, std::string> out;
-    for (auto &[index, node] : node_of) out[node] = names[index];
-    return out;
-}
-
+// which calibrated camera each capture pipe carries (XRService's fixed routing)
 const char *camera_for_pipe(int node) {
    char path[64], name[64] = "";
    std::snprintf(path, sizeof path, "/sys/class/video4linux/video%d/name", node);
@@ -329,7 +302,6 @@ int main(int argc, char **argv) {
    double decided_after_s = -1;
    if (sides_mode != "auto") truth = names_swapped, decided_by = sides_from, sides_state = "forced";
    std::string rec_dir;
-    std::string cams_json;   // which device each calibrated camera is (set below), for the sides files
    std::vector<std::pair<size_t, bool>> rec_names;   // from which recorded set on, names_swapped was what
    // DIR/sides.json beside a recording's sets.bin: how its side cameras are named. A set's
    // names are right when its names_swapped equals swapped (null: not known when recorded).
@@ -340,8 +312,7 @@ int main(int argc, char **argv) {
        write_file(rec_dir + "/sides.json",
                   "{\"swapped\": " + json_bool(truth) + ", \"decided_by\": " + json_str(truth ? decided_by : "") +
                       ", \"names_swapped\": [" + runs + "]" +
-                       (decision_evidence.empty() ? "" : ", \"evidence\": " + decision_evidence) +
-                       (cams_json.empty() ? "" : ", \"cameras\": " + cams_json) + "}\n");
+                       (decision_evidence.empty() ? "" : ", \"evidence\": " + decision_evidence) + "}\n");
    };
    auto start_recording = [&](const std::string &dir, std::string &e) {
        rec = std::make_unique<Recorder>();
@@ -369,42 +340,19 @@ int main(int argc, char **argv) {
    // (--with-color). Recorded names hold 15 characters, so "upper_right_dark" wouldn't fit.
    std::map<std::string, int> dark;
    std::map<std::string, Camera> used;
-    // ft-camd's cameras by XRService's numbering, else by capture pipe (see camera_for_pipe);
-    // ft-ringplay's (no device) by the name it gives
-    const std::map<int, std::string> by_log = cameras_from_xrservice_log();
-    const char *named_by = by_log.empty() ? "capture pipe" : "XRService's log";
    for (int i = 0; i < ring.cameras(); ++i) {
-        const fh_ring_cam_t &rc = ring.camera(i);
-        if (rc.flags & FH_CAM_COLOR) {
-            const std::string name = "color_video" + std::to_string(rc.node);
+        if (ring.camera(i).flags & FH_CAM_COLOR) {
+            const std::string name = "color_video" + std::to_string(ring.camera(i).node);
            dark[name] = i, color[name] = i;
            continue;
        }
-        const auto it = by_log.find(rc.node);
-        const char *name = rc.node < 0                ? rc.name
-                           : !by_log.empty()          ? (it == by_log.end() ? nullptr : it->second.c_str())
-                                                      : camera_for_pipe(rc.node);
-        if (!name || !calib.count(name)) {
-            if (!(rc.flags & FH_CAM_DARK)) std::fprintf(stderr, "video%d (%s): not one of the calibrated cameras, left out\n", rc.node, rc.name);
-            continue;
-        }
-        if (int(rc.width) != calib[name].width || int(rc.height) != calib[name].height) {
-            std::fprintf(stderr, "video%d (%s) is %ux%u, but %s is calibrated at %dx%d: left out\n", rc.node, rc.name,
-                         rc.width, rc.height, name, calib[name].width, calib[name].height);
-            continue;
-        }
-        if (rc.flags & FH_CAM_DARK) {
-            dark[std::string(name) + "_dk"] = i;
-        } else if (index.count(name)) {
-            std::fprintf(stderr, "video%d (%s) would be %s too (video%d is): left out\n", rc.node, rc.name, name,
-                         ring.camera(index[name]).node);
-        } else {
-            index[name] = i, used[name] = calib[name];
-            cams_json += std::string(cams_json.empty() ? "" : ", ") + json_str(name) + ": {\"node\": " +
-                         std::to_string(rc.node) + ", \"ring\": " + json_str(rc.name) + "}";
-        }
+        // ft-camd's cameras by capture pipe; ft-ringplay's (no device) by the name it gives
+        const char *name = camera_for_pipe(ring.camera(i).node);
+        if (!name && ring.camera(i).node < 0) name = ring.camera(i).name;
+        if (!name || !calib.count(name)) continue;
+        if (ring.camera(i).flags & FH_CAM_DARK) dark[std::string(name) + "_dk"] = i;
+        else index[name] = i, used[name] = calib[name];
    }
-    cams_json = "{\"named_by\": " + json_str(named_by) + ", \"cameras\": {" + cams_json + "}}";
    // ft-camd tells the side cameras' buffers apart by XRService's allocation order, which
    // some XRService restarts reverse (see the top).
    const bool have_sides = index.count("slam_left") && index.count("slam_right");
@@ -449,7 +397,7 @@ int main(int argc, char **argv) {
    }
    const bool switching = automatic && !color.empty();
    Cams mode = switching || color.empty() ? Cams::Mono : fixed;
-    std::printf("cameras (by %s):", named_by);
+    std::printf("cameras:");
    for (auto &[name, i] : index) std::printf(" %s=video%d", name.c_str(), ring.camera(i).node);
    for (auto &[name, i] : color) std::printf(" %s", name.c_str());
    std::printf("  tracking with %s%s  models: %s%s, %d threads on CPUs", cams_name(mode),
@@ -498,7 +446,6 @@ int main(int argc, char **argv) {
                       ", \"decided_after_s\": " + std::to_string(decided_after_s) +
                       ", \"evidence\": " + (decision_evidence.empty() ? "null" : decision_evidence) +
                       ", \"checking\": " + (checking ? side_check.json() : "null") +
-                       ", \"cameras\": " + (cams_json.empty() ? "null" : cams_json) +
                       ", \"updated_ns\": " + std::to_string(mono_ns()) + "}\n");
    };
    write_sides();
@@ -77,8 +77,6 @@ ACTION_LABELS = {
    "screens_toggle": "Hide/show desktop screens", "keyboard_toggle": "Open/close keyboard",
    "float_toggle": "Float window in VR / put it back", "dock_all": "Put all floating windows back",
    "pause_toggle": "Pause/resume Frametop (for VR games)",
-    "spin_next": "Spin the panels: next one on the right to the front",
-    "spin_prev": "Spin the panels: next one on the left to the front",
    "key": "Pass through as key",
    "none": "Do nothing",
 }
@@ -165,10 +163,9 @@ GAZE_MOUSE = {"precision": "Gaze precision: hold to steer with the mouse, releas
 MODIFIER_CODES = {29: 29, 97: 29, 42: 42, 54: 42, 56: 56, 100: 56, 125: 125, 126: 125}
 MODIFIER_NAMES = {29: "Ctrl", 42: "Shift", 56: "Alt", 125: "Meta"}
 # What a rules file without "key_bindings" gets (the relay's DEFAULT_KEY_BINDINGS): a Meta tap
-# opens Steam's menu, Meta+J and Meta+K click at the gaze, Meta+Shift+F floats a window,
-# Meta+Alt+Tab and Meta+Alt+Shift+Tab spin the panels.
+# opens Steam's menu, Meta+J and Meta+K click at the gaze, Meta+Shift+F floats a window.
 DEFAULT_KEY_BINDINGS = {"125": "steam_menu", "125+36": "gaze_left", "125+37": "gaze_right",
-                        "42+125+33": "float_toggle", "56+125+15": "spin_next", "42+56+125+15": "spin_prev"}
+                        "42+125+33": "float_toggle"}


 def key_bindings(rules):
@@ -30,9 +30,7 @@ gaze_quickcal = the gaze service's one-dot check ("quickcal" to @ft_gazed), sens
 layout_reset = put the desktop screens back in their saved layout, screens_toggle = hide or show the desktop screens,
 keyboard_toggle = open or close Frametop's keyboard, float_toggle = float the desktop window under the
 pointer (else the active one) in VR, or put it back if it floats, dock_all = put every floating
-window back (both to ft-floatd, @frametop_float), spin_next and spin_prev = turn every panel in the
-room about your head so the next one to the right or left comes to the front (ft-screens' "spin",
-Meta+Alt+Tab and Meta+Alt+Shift+Tab by default), profile:NAME = switch to that profile (ft-layout
+window back (both to ft-floatd, @frametop_float), profile:NAME = switch to that profile (ft-layout
 use NAME: its screens and apps; docs/profiles.md), steam_menu = open the SteamVR dashboard on
 Steam's menu, or close the dashboard (steam/ft-steam menu, through Steam's UI), pause_toggle =
 pause Frametop for a VR game, or resume it (game_pause.py), command:CMD = run
@@ -154,10 +152,10 @@ REL_X, REL_Y, REL_WHEEL, REL_MAX = 0x00, 0x01, 0x08, 0x0F
 SCROLLS = {0x06, REL_WHEEL, 0x0B, 0x0C}  # REL_HWHEEL, REL_WHEEL and their _HI_RES
 BTN_LEFT, BTN_RIGHT, BTN_MIDDLE, BTN_SIDE, BTN_EXTRA = 0x110, 0x111, 0x112, 0x113, 0x114
 KEY_LEFTMETA, KEY_RIGHTMETA = 125, 126
-KEY_MUTE, KEY_VOLUMEDOWN, KEY_VOLUMEUP = 113, 114, 115
-# Volume keys are remapped to KEY_MACRO28, KEY_MACRO29 and KEY_MACRO30: above 255, so X11
-# can't carry them, and bound to nothing in the default keymap.
-VOLUME_STANDIN = {KEY_MUTE: 0x2AB, KEY_VOLUMEUP: 0x2AC, KEY_VOLUMEDOWN: 0x2AD}
+KEY_VOLUMEDOWN, KEY_VOLUMEUP = 114, 115
+# Volume keys are remapped to KEY_MACRO29 and KEY_MACRO30: above 255, so X11 can't
+# carry them, and bound to nothing in the default keymap.
+VOLUME_STANDIN = {KEY_VOLUMEUP: 0x2AC, KEY_VOLUMEDOWN: 0x2AD}
 VOLUME_ORIGINAL = {v: k for k, v in VOLUME_STANDIN.items()}
 VOLUME_CODES = set(VOLUME_STANDIN) | set(VOLUME_ORIGINAL)
 BUS_USB, BUS_BLUETOOTH, BUS_VIRTUAL = 0x03, 0x05, 0x06
@@ -211,16 +209,14 @@ RULES_PATH = os.path.expanduser("~/.config/frametop-input.json")
 ACTIONS = ("left", "right", "middle", "back", "scroll_up", "scroll_down", "dashboard", "recenter",
           "pointer_toggle", "follow_toggle", "gaze_toggle", "gaze_precision", "gaze_drag", "gaze_left", "gaze_right",
           "gaze_quickcal", "sens_up", "sens_down", "layout_reset", "screens_toggle", "keyboard_toggle", "float_toggle",
-           "dock_all", "spin_next", "spin_prev", "steam_menu", "pause_toggle", "key", "none")
+           "dock_all", "steam_menu", "pause_toggle", "key", "none")
 # Gaze mode is a mouse feature: these never come from a controller button (docs/gaze-controllers.md).
 GAZE_ACTIONS = ("gaze_toggle", "gaze_precision", "gaze_drag", "gaze_left", "gaze_right", "gaze_quickcal")
 # Key combinations a rules file without "key_bindings" gets: a Meta tap opens Steam's menu, Meta+J
 # and Meta+K click at the gaze (free on the Frametop desktop, and apps don't use Meta),
-# Meta+Shift+F floats a window, and Meta+Alt+Tab and Meta+Alt+Shift+Tab spin the panels around
-# you (ft-screens' lazy susan); not Meta+Tab, which is Cmd+Tab on a Mac reached through a remote
-# desktop like RustDesk.
+# Meta+Shift+F floats a window.
 DEFAULT_KEY_BINDINGS = {"125": "steam_menu", "125+36": "gaze_left", "125+37": "gaze_right",
-                        "42+125+33": "float_toggle", "56+125+15": "spin_next", "42+56+125+15": "spin_prev"}
+                        "42+125+33": "float_toggle"}
 KEY_F24 = 194  # sent to the desktop with a Meta combination (see the top)
 # Key combinations ("key_bindings"): modifiers, each side's code folded into the left one's.
 MODIFIERS = {29: 29, 97: 29, 42: 42, 54: 42, 56: 56, 100: 56, 125: 125, 126: 125}
@@ -236,9 +232,6 @@ GAZED = "\0ft_gazed"
 FLOAT = "\0frametop_float"  # ft-floatd, floating windows in the Frametop desktop
 # Actions for ft-floatd ("float_toggle", "dock_all"): they don't need pointer mode.
 FLOAT_ACTIONS = {"float_toggle": b"float pointer", "dock_all": b"dock all"}
-# Actions for ft-screens: spin_next and spin_prev turn every panel in the room about your head,
-# so the next one to the right or left comes to the front. They don't need pointer mode either.
-SCREENS_ACTIONS = {"spin_next": b"spin next", "spin_prev": b"spin prev"}
 PROFILE = "profile:"  # "profile:NAME": switch to that profile (doesn't need pointer mode either)
 COMMAND = "command:"  # "command:CMD": run CMD (nor does this)

@@ -249,7 +242,7 @@ def known_action(a):


 def needs_pointer(a):
-    return a not in FLOAT_ACTIONS and a not in SCREENS_ACTIONS and a not in ("steam_menu", "pause_toggle") and not a.startswith((PROFILE, COMMAND))
+    return a not in FLOAT_ACTIONS and a not in ("steam_menu", "pause_toggle") and not a.startswith((PROFILE, COMMAND))


 def works_paused(a):
@@ -429,13 +422,9 @@ class Volume:

    def key(self, fd, code, value, now):
        if value == 1:
-            if VOLUME_ORIGINAL.get(code, code) == KEY_MUTE:
-                subprocess.Popen(["wpctl", "set-mute", "@DEFAULT_AUDIO_SINK@", "toggle"],
-                                stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-            else:
-                self.held = (fd, code)
-                self.step(code)
-                self.next_at = now + self.DELAY
+            self.held = (fd, code)
+            self.step(code)
+            self.next_at = now + self.DELAY
        elif value == 0 and self.held == (fd, code):
            self.release()

@@ -936,13 +925,6 @@ def main():
                except OSError:
                    pass  # the Frametop desktop isn't running
                log(action)
-        elif action in SCREENS_ACTIONS:
-            if value == 1:
-                try:
-                    screens_sock.sendto(SCREENS_ACTIONS[action], SCREENS)
-                except OSError:
-                    pass  # the Frametop desktop isn't running
-                log(action)
        elif state["pointer"]:
            state["pointer"].action(action, value, now, source)

@@ -206,7 +206,7 @@ def check(label, got, want):
        failures.append(label)


-META, RMETA, SHIFT, CTRL, RCTRL, ALT, A, F, J, P, TAB = 125, 126, 42, 29, 97, 56, 30, 33, 36, 25, 15
+META, RMETA, SHIFT, CTRL, RCTRL, A, F, J, P = 125, 126, 42, 29, 97, 30, 33, 36, 25
 F24 = ["key 194 1", "key 194 0"]


@@ -265,20 +265,6 @@ def tests():
    key(META, 1); key(J, 1); key(J, 0); key(META, 0)
    check("resumed: Meta+J is a combination again", typed(), ["key 125 1"] + F24 + ["key 125 0"])

-    use(None)  # the defaults: Meta+Alt+Tab and Meta+Alt+Shift+Tab spin the panels (ft-screens)
-    key(META, 1); key(ALT, 1); key(TAB, 1); key(TAB, 0); key(ALT, 0); key(META, 0)
-    got = typed()
-    check("Meta+Alt+Tab (default): spin next", [m for m in got if m.startswith("spin")], ["spin next"])
-    check("Meta+Alt+Tab: Tab isn't typed", [m for m in got if m.startswith("key 15 ")], [])
-    key(META, 1); key(ALT, 1); key(SHIFT, 1); key(TAB, 1); key(TAB, 0); key(SHIFT, 0); key(ALT, 0); key(META, 0)
-    check("Meta+Alt+Shift+Tab (default): spin prev", [m for m in typed() if m.startswith("spin")], ["spin prev"])
-    pause("on")
-    key(META, 1); key(ALT, 1); key(TAB, 1); key(TAB, 0); key(ALT, 0); key(META, 0)
-    check("paused: Meta+Alt+Tab doesn't spin", [m for m in typed() if m.startswith("spin")], [])
-    pause("off")
-    check("spinning works without pointer mode", (relay.needs_pointer("spin_next"), relay.needs_pointer("spin_prev")),
-          (False, False))
-
    check("an empty command isn't an action", relay.known_action("command:  "), False)
    check("steam_menu, pause_toggle and commands work without pointer mode",
          (relay.needs_pointer("steam_menu"), relay.needs_pointer("pause_toggle"), relay.needs_pointer("command:ls")),
@@ -1,3 +0,0 @@
-#!/bin/bash
-# Hide/Show Screens' own program (see ft-layout-reset).
-exec "$(dirname "$(readlink -f "$0")")/ft-layout" toggle "$@"
@@ -1,4 +0,0 @@
-#!/bin/bash
-# Reset Screen Layout's own program. Steam lists menu entries by program, so entries that
-# shared ft-layout (with different arguments) launched as one.
-exec "$(dirname "$(readlink -f "$0")")/ft-layout" apply "$@"
@@ -346,20 +346,6 @@ static void handle_vr_event(const struct ft_event *e, void *data) {
    if (e->screen < 0 || e->screen >= MAX_SCREENS || !s->screens[e->screen]) return;
    struct screen *sc = s->screens[e->screen];
    struct wlr_surface *surface = sc->toplevel->base->surface;
-    if (e->type == FT_FRONT) {
-        // A spin brought this panel to the front: typing goes to it, as after a click there,
-        // and ft-floatd makes its window (or the top one on a screen) KWin's active window.
-        wlr_seat_keyboard_notify_enter(s->seat, surface, NULL, 0, NULL);
-        s->keys_clicked = true;
-        char msg[32];
-        snprintf(msg, sizeof msg, "front %d", e->screen + 1);
-        struct sockaddr_un addr = {.sun_family = AF_UNIX};
-        const char name[] = "frametop_float";
-        memcpy(addr.sun_path + 1, name, sizeof name - 1);
-        sendto(s->relay_fd, msg, strlen(msg), MSG_DONTWAIT, (struct sockaddr *)&addr,
-               offsetof(struct sockaddr_un, sun_path) + 1 + sizeof name - 1);
-        return;
-    }
    const uint32_t t = now_ms();
    const double x = e->x / s->scale[e->screen], y = e->y / s->scale[e->screen];  // KWin's units
    switch (e->type) {
@@ -809,9 +795,7 @@ static bool setup_dmabuf(struct server *s) {

 int main(int argc, char **argv) {
    struct server s = {0};
-    // About 0.9 degrees on a 3.4 m wide 3440-pixel screen 2 m away; 8 (the first default,
-    // about 0.2 degrees) needed a very still hand to click (headset test 2026-10-03).
-    s.controller_click.threshold = 32;
+    s.controller_click.threshold = 8;
    for (int i = 0; i < MAX_SCREENS; ++i) s.scale[i] = 1;
    s.kb_screen = -1;
    s.rate[FT_FOCUSED] = 0, s.rate[FT_IN_VIEW] = 15, s.rate[FT_HIDDEN] = 1;
@@ -459,21 +459,7 @@ void Hide() {
 bool Shown() { return g_shown; }

 void SetLasers(bool on) {
-    static vr::VROverlayHandle_t set = vr::k_ulOverlayHandleInvalid;  // the overlay `was` is for
-    static bool was = false;
-    if (!Create() || (set == g_overlay && was == on)) return;
-    set = g_overlay, was = on;
-    vr::VROverlay()->SetOverlayFlag(g_overlay, vr::VROverlayFlags_MakeOverlaysInteractiveIfVisible, on);
-}
-
-bool Aimed(const vr::HmdMatrix34_t &laser) {
-    if (!g_shown) return false;
-    vr::VROverlayIntersectionParams_t in{};
-    in.eOrigin = vr::TrackingUniverseStanding;
-    in.vSource = {laser.m[0][3], laser.m[1][3], laser.m[2][3]};
-    in.vDirection = {-laser.m[0][2], -laser.m[1][2], -laser.m[2][2]};
-    vr::VROverlayIntersectionResults_t out{};
-    return vr::VROverlay()->ComputeOverlayIntersection(g_overlay, &in, &out);
+    if (Create()) vr::VROverlay()->SetOverlayFlag(g_overlay, vr::VROverlayFlags_MakeOverlaysInteractiveIfVisible, on);
 }

 void Poll(void (*handle)(const Event &, void *), void *data) {
@@ -26,8 +26,6 @@ const vr::HmdMatrix34_t &Pose();
 void EndDragBy(uint32_t device);
 // Controllers' lasers work the panel with the dashboard closed, like the screens'.
 void SetLasers(bool on);
-// A laser (its pose, aiming along -z) points at the panel.
-bool Aimed(const vr::HmdMatrix34_t &laser);
 // The panel's input: key presses and releases, and Closed for its Close key.
 void Poll(void (*handle)(const Event &, void *), void *data);
 void Destroy();
@@ -12,7 +12,9 @@
 //   - a resize tab on the bottom right corner: drag it to set the width (the height
 //     follows the screen's resolution).
 //   - a reset button left of the bar: every screen back in its layout, around where you
-//     are now (`ft-layout apply`, like Meta+Shift+R).
+//     are now (`ft-layout apply`, like Meta+Shift+R). Where the screens leave the
+//     controllers to a VR game, aiming a controller at it turns SteamVR's laser mouse on for
+//     that button alone (UpdateResetLaser), so it can be clicked in a game.
 //   The controls are translucent, like SteamVR's own, and brighten under a laser. They
 //   are invisible until a laser (a controller's, or the 3D mouse's) lands on or passes very close to
 //   one of them (UpdateControls).
@@ -42,10 +44,7 @@
 //     default it's off while a game (a scene app) runs: the screens stay up over the game,
 //     the controllers stay in it, and the 3D mouse (its own laser mode) or the dashboard
 //     works the screens. Modes: always, outside_games (default), dashboard (never on its
-//     own; also for flatscreen games, which aren't scene apps). Where the mode leaves the
-//     controllers to the game, pointing a controller at a panel (a screen, a floating window
-//     and its popups, their controls, the keyboard) turns the laser on for it until you
-//     point away, like SteamVR's own floating windows (UpdateAim).
+//     own; also for flatscreen games, which aren't scene apps).
 //   - during a VR game the screens hide unless the dashboard is open (g_inGames, default),
 //     or stay visible over it; the hotkey still shows them.
 //   - paused ("pause on", from the input relay when Frametop pauses for a VR game,
@@ -190,12 +189,8 @@ Mat TipOffset(vr::TrackedDeviceIndex_t dev) {
    Tip tip{model, Identity(), false, now};
    vr::RenderModel_ControllerMode_State_t mode{};
    vr::RenderModel_ComponentState_t state{};
-    // GetComponentState, not GetComponentStateForDevicePath: without an input source handle
-    // the latter fails for every component while a VR game runs, and the rays came from the
-    // pose, 40 degrees above the laser. The tip doesn't move with the buttons.
-    vr::VRControllerState_t buttons{};
-    if (model[0] && vr::VRRenderModels()->GetComponentState(model, vr::k_pch_Controller_Component_Tip, &buttons, &mode,
-                                                            &state))
+    if (model[0] && vr::VRRenderModels()->GetComponentStateForDevicePath(model, vr::k_pch_Controller_Component_Tip,
+                                                                          vr::k_ulInvalidInputValueHandle, &mode, &state))
        tip.offset = state.mTrackingToComponentLocal, tip.found = true;
    cache[dev] = tip;
    return tip.offset;
@@ -242,7 +237,7 @@ constexpr double kRollSnap = 2.5;    // degrees from level where rolling snaps l
 constexpr double kRollStep = 5;      // degrees per scroll notch on the roll button
 constexpr float kChromeIdle = 0.55f; // the controls' opacity without a laser on them
 constexpr long kControlsLinger = 35; // ticks (~0.4 s) the controls stay after a laser leaves
-constexpr long kAimLinger = 25;      // ticks (~0.3 s) a panel keeps the laser on after the aim leaves it
+constexpr long kResetLinger = 45;    // ticks (~0.5 s) the reset button keeps the laser mouse on
 long g_tick = 0;                     // ft_vr_poll calls
 bool g_vr = false;                   // connected to SteamVR (ft-screens --no-vr runs without it)
 constexpr vr::TrackedDeviceIndex_t kNone = vr::k_unTrackedDeviceIndexInvalid;
@@ -280,7 +275,8 @@ struct Screen {
    float controls = 0;                       // the controls' fade, 0 (hidden) .. 1
    bool controlsUp = false;                  // the controls' overlays are shown
    long nearUntil = 0;                       // a laser was near the controls until this tick
-    long aimUntil = 0;                        // a hand controller pointed at it until this tick (UpdateAim)
+    long resetNearUntil = 0;                  // a hand controller aimed at the reset button until this tick
+    bool resetLaser = false;                  // the reset button has MakeOverlaysInteractiveIfVisible
    vr::TrackedDeviceIndex_t pinTarget = kNone;  // moving: rides on this controller when let go
    vr::TrackedDeviceIndex_t onWrist = kNone;    // moving: the laser is in this controller's ring
    bool barLit = false;
@@ -914,20 +910,26 @@ void UpdateAttention() {


 // Controllers' lasers on the screens (see the top): the flag follows the mode and whether a
-// VR game runs, and where the mode leaves the controllers to the game, whether one points at
-// the panel (UpdateAim).
-bool LasersByMode() { return g_lasers == Lasers::Always || (g_lasers == Lasers::OutsideGames && !g_gameRunning); }
-long g_keyboardAimUntil = 0;
-
+// VR game runs.
 void UpdateLasers() {
-    const bool byMode = LasersByMode();
+    const bool want = g_lasers == Lasers::Always || (g_lasers == Lasers::OutsideGames && !g_gameRunning);
    for (auto &[i, s] : g_screens) {
-        const bool want = byMode || (s.visible && g_tick < s.aimUntil);
        if (s.lasers == want) continue;
        s.lasers = want;
        vr::VROverlay()->SetOverlayFlag(s.overlay, vr::VROverlayFlags_MakeOverlaysInteractiveIfVisible, want);
    }
-    if (keyboard::Shown()) keyboard::SetLasers(byMode || g_tick < g_keyboardAimUntil);
+}
+
+// The reset button in a VR game (or the dashboard mode), where the screens don't keep
+// SteamVR's laser mouse on: aiming a hand controller at it turns the laser mouse on for that
+// button alone, so the trigger clicks it, and the game gets the controllers back
+// kResetLinger ticks after the aim leaves it (a wider zone than the one that turns it on).
+void UpdateResetLaser(Screen &s) {
+    const bool want = s.resetButton != vr::k_ulOverlayHandleInvalid && s.visible && !s.lasers &&
+                      g_tick < s.resetNearUntil;
+    if (want == s.resetLaser) return;
+    s.resetLaser = want;
+    vr::VROverlay()->SetOverlayFlag(s.resetButton, vr::VROverlayFlags_MakeOverlaysInteractiveIfVisible, want);
 }

 // The distance from a laser's line to a point ahead of it, or -1 when it's behind.
@@ -945,10 +947,11 @@ double RayDistance(const Mat &d, const Mat &c) {
 // kControlsLinger ticks after it leaves, and while in use.
 void UpdateControls() {
    std::vector<Mat> lasers;
+    std::vector<bool> hands;  // the laser is a hand controller's (not the 3D mouse's)
    for (vr::TrackedDeviceIndex_t i = 1; i < vr::k_unMaxTrackedDeviceCount; ++i) {
        Mat d;
        if (vr::VRSystem()->GetTrackedDeviceClass(i) == vr::TrackedDeviceClass_Controller && LaserPose(i, &d))
-            lasers.push_back(d);
+            lasers.push_back(d), hands.push_back(IsHandController(i));
    }
    for (auto &[i, s] : g_screens) {
        Mat p;
@@ -974,7 +977,16 @@ void UpdateControls() {
                    break;
                }
            }
+            if (s.resetButton != vr::k_ulOverlayHandleInvalid && !s.lasers) {
+                const Mat c = Mul(p, offsets[6]);
+                const double aim = s.grip * (s.resetLaser ? 2.0 : 0.9);
+                for (size_t k = 0; k < lasers.size(); ++k) {
+                    const double r = RayDistance(lasers[k], c);
+                    if (hands[k] && r >= 0 && r <= aim) s.resetNearUntil = g_tick + kResetLinger;
+                }
+            }
        }
+        UpdateResetLaser(s);
        const bool inUse = s.drag != Drag::None || std::any_of(std::begin(s.hover), std::end(s.hover), [](bool h) { return h; });
        const bool want = s.visible && (inUse || g_tick < s.nearUntil);
        // The controls stay shown while their screen is, just fully transparent when not
@@ -1008,21 +1020,19 @@ void SendFloat(const std::string &msg) {
        std::printf("to ft-floatd: %s\n", msg.c_str());
 }

-// To the pointer helper (@ft_pointer_helper), from an unbound socket.
-void SendPointer(const std::string &msg) {
+// A new panel: the pointer helper reads SteamVR's list of panels only every 20 s, so it's told
+// at once ("overlay <key>"), or the mouse couldn't click a menu until then.
+void AnnounceOverlay(const char *key) {
    static const int fd = socket(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
    sockaddr_un addr{};
    addr.sun_family = AF_UNIX;
    const char name[] = "ft_pointer_helper";
    std::memcpy(addr.sun_path + 1, name, sizeof name - 1);
+    const std::string msg = std::string("overlay ") + key;
    sendto(fd, msg.data(), msg.size(), MSG_DONTWAIT, reinterpret_cast<sockaddr *>(&addr),
           socklen_t(offsetof(sockaddr_un, sun_path) + 1 + sizeof name - 1));
 }

-// A new panel: the pointer helper reads SteamVR's list of panels only every 20 s, so it's told
-// at once ("overlay <key>"), or the mouse couldn't click a menu until then.
-void AnnounceOverlay(const char *key) { SendPointer(std::string("overlay ") + key); }
-
 // Where a device's ray meets the screen's plane, in the screen's x (right) and y (up),
 // metres from its centre.
 bool RayOnPlane(const Mat &p, const Mat &d, double *x, double *y) {
@@ -1409,7 +1419,6 @@ struct Press {
    double x = 0, y = 0;                      // ...and where on it, in buffer pixels
    double distance = 1;                      // from the laser's start to the last panel it met
    long upAt = -1;                           // the pointer helper saw left come up: release it at this tick
-    int64_t idleSince = -1;                   // the pressing controller has held nothing since (ms, ReleaseStuck)
 };
 Press g_press;
 vr::VROverlayHandle_t g_catcher = vr::k_ulOverlayHandleInvalid;
@@ -1446,47 +1455,6 @@ void ReleaseAway(uint32_t button, void (*handle)(const struct ft_event *, void *
    handle(&e, data);
 }

-// Whether a hand controller holds anything (a button down): 1 yes, 0 no, -1 unknown. SteamVR
-// answers overlay apps only while a VR game runs (checked 2026-10-04); outside games it can't
-// say. The Frame controller's axes have no types, so the buttons are all there is.
-int ControllerHolds(vr::TrackedDeviceIndex_t dev) {
-    vr::VRControllerState_t st{};
-    if (!vr::VRSystem()->GetControllerState(dev, &st, sizeof st)) return -1;
-    return st.ulButtonPressed ? 1 : 0;
-}
-
-// Releases SteamVR never sends. Pausing, or hiding the screen a button went down on, takes the
-// laser off it mid-click (the pause gesture's second thumbstick click does that), and SteamVR's
-// laser mouse then forgets the button: no release comes, the catcher stayed up, and the game
-// never got its controllers back (2026-10-04). So a held button is released here when it has
-// no visible screen to come up on, or when its hand controller has held nothing for kStuckMs
-// (only known during VR games, where the lost release took the game's controllers).
-// The pointer helper's virtual controller has its own word for that ("up").
-constexpr int64_t kStuckMs = 1000;
-void ReleaseStuck(void (*handle)(const struct ft_event *, void *), void *data) {
-    if (!g_press.buttons) {
-        g_press.idleSince = -1;
-        return;
-    }
-    const char *why = nullptr;
-    const auto it = g_screens.find(g_press.screen);
-    if (g_paused) why = "paused";
-    else if (g_press.screen >= 0 && (it == g_screens.end() || !it->second.visible)) why = "its screen hid";
-    else if (IsHandController(g_press.device)) {
-        const int64_t now = NowMs();
-        if (ControllerHolds(g_press.device) != 0) g_press.idleSince = -1;
-        else if (g_press.idleSince < 0) g_press.idleSince = now;
-        else if (now - g_press.idleSince >= kStuckMs) why = "the controller holds nothing";
-    }
-    if (!why) return;
-    std::printf("a held button can't come up on a screen (%s): released\n", why);
-    const vr::TrackedDeviceIndex_t dev = g_press.device;
-    for (uint32_t b = 0; b < 32; ++b)
-        if (g_press.buttons & (1u << b)) ReleaseAway(BTN_LEFT + b, handle, data);
-    g_press.buttons = 0, g_press.upAt = -1, g_press.idleSince = -1;
-    EndDragsBy(dev);
-}
-
 void ShowCatcher(bool on) {
    if (on == g_catcherShown || g_catcher == vr::k_ulOverlayHandleInvalid) return;
    g_catcherShown = on;
@@ -1532,137 +1500,6 @@ Screen *Find(int one_based) {
    return it == g_screens.end() ? nullptr : &it->second;
 }

-// ---------------------------------------------------------------- the lazy susan
-// "spin next|prev|<degrees>": the panels in the room (screens and floating windows, not
-// pinned ones) turn together about a vertical axis through your head, so the next panel to
-// your right (next) or left (prev) glides to straight ahead, or the ring turns by that many
-// degrees (positive turns it left, like next). Their arrangement stays as it is: the room
-// turns instead of you. A spin that arrives during one adds to it, from where the panels are
-// headed, so quick taps carry on smoothly. Grabbing a panel, or a command that places it,
-// takes it out of the spin where it is. The 3D mouse's pointer goes to straight ahead.
-constexpr double kSpinSeconds = 0.3;  // how long a spin takes
-constexpr double kSpinAhead = 8;      // degrees: a panel this near straight ahead is the current one
-constexpr double kSpinFocus = 30;     // degrees: when a spin settles, the panel this near ahead gets typing
-
-struct Spin {
-    bool on = false;
-    double cx = 0, cz = 0;    // the axis
-    double from = 0, to = 0;  // radians, turned from the poses in base (positive: to the left)
-    Clock::time_point start;
-    std::map<int, Mat> base;  // index -> its pose before the spin
-    int front = -1;           // settled: this panel came to the front (ft_vr_poll reports it)
-} g_spin;
-
-// p turned a radians about the vertical axis through (cx, cz); positive turns it to the left.
-Mat Turned(const Mat &p, double a, double cx, double cz) {
-    const double c = std::cos(a), s = std::sin(a);
-    Mat r = Identity();
-    r.m[0][0] = float(c), r.m[0][2] = float(s);
-    r.m[2][0] = float(-s), r.m[2][2] = float(c);
-    r.m[0][3] = float(cx - c * cx - s * cz);
-    r.m[2][3] = float(cz + s * cx - c * cz);
-    return Mul(r, p);
-}
-
-bool Spinnable(const Screen &s) { return s.pinned == kNone && (!s.floating || s.floatOn) && s.drag == Drag::None; }
-
-double SpinNow() {
-    if (!g_spin.on) return g_spin.to;
-    const double t = std::min(1.0, std::chrono::duration<double>(Clock::now() - g_spin.start).count() / kSpinSeconds);
-    return g_spin.from + (g_spin.to - g_spin.from) * t * t * (3 - 2 * t);
-}
-
-void UpdateSpin() {
-    if (!g_spin.on) return;
-    const double a = SpinNow();
-    const bool done = Clock::now() - g_spin.start >= std::chrono::duration<double>(kSpinSeconds);
-    for (auto it = g_spin.base.begin(); it != g_spin.base.end();) {
-        auto s = g_screens.find(it->first);
-        if (s == g_screens.end() || !Spinnable(s->second)) {
-            it = g_spin.base.erase(it);  // grabbed, pinned, or gone: it stays where it is now
-            continue;
-        }
-        SetAbsolute(s->second, Turned(it->second, a, g_spin.cx, g_spin.cz));
-        ++it;
-    }
-    if (done) {
-        // The panel now nearest straight ahead (of where you face) gets typing and the active window.
-        Mat head;
-        double nearest = kSpinFocus;
-        if (DevicePose(vr::k_unTrackedDeviceIndex_Hmd, &head)) {
-            for (const auto &[i, p] : g_spin.base) {
-                const auto it = g_screens.find(i);
-                Mat q;
-                if (it == g_screens.end() || !it->second.visible || !ScreenPose(it->second, &q)) continue;
-                double f[3] = {-head.m[0][2], 0, -head.m[2][2]};
-                double d[3] = {q.m[0][3] - head.m[0][3], 0, q.m[2][3] - head.m[2][3]};
-                const double fl = std::sqrt(Dot3(f, f)), dl = std::sqrt(Dot3(d, d));
-                if (fl < 1e-6 || dl < 1e-6) continue;
-                const double a = std::acos(std::clamp(Dot3(f, d) / (fl * dl), -1.0, 1.0)) * 180 / M_PI;
-                if (a < nearest) nearest = a, g_spin.front = i;
-            }
-        }
-        g_spin.on = false;
-        g_spin.base.clear();
-        ArrangeDesktopSoon();  // KWin's outputs follow where the screens are now
-    }
-}
-
-void SpinCommand(const char *arg, char *reply, int size) {
-    Mat head;
-    if (!DevicePose(vr::k_unTrackedDeviceIndex_Hmd, &head))
-        return (void)std::snprintf(reply, size, "error no head pose (headset off?)");
-    if (g_spin.on) {
-        g_spin.from = SpinNow();  // carry on from where the panels are now
-    } else {
-        g_spin.base.clear();
-        for (auto &[i, s] : g_screens) {
-            Mat p;
-            if (Spinnable(s) && ScreenPose(s, &p)) g_spin.base[i] = p;
-        }
-        g_spin.cx = head.m[0][3], g_spin.cz = head.m[2][3];
-        g_spin.from = g_spin.to = 0;
-    }
-    if (g_spin.base.empty()) return (void)std::snprintf(reply, size, "error nothing to spin");
-    double turn;  // degrees, positive to the left
-    const bool next = !std::strcmp(arg, "next");
-    if (next || !std::strcmp(arg, "prev")) {
-        // Each visible panel's bearing from where you face, to the right positive, as it will
-        // be when the spin so far ends; the nearest one past straight ahead comes to the front.
-        double fx = -head.m[0][2], fz = -head.m[2][2];
-        const double n = std::sqrt(fx * fx + fz * fz) + 1e-9;
-        fx /= n, fz /= n;
-        const double rx = -fz, rz = fx;
-        double best = 0;
-        bool found = false;
-        for (const auto &[i, p] : g_spin.base) {
-            const auto s = g_screens.find(i);
-            if (s == g_screens.end() || !s->second.visible) continue;
-            const Mat q = Turned(p, g_spin.to, g_spin.cx, g_spin.cz);
-            const double dx = q.m[0][3] - head.m[0][3], dz = q.m[2][3] - head.m[2][3];
-            double a = std::atan2(dx * rx + dz * rz, dx * fx + dz * fz) * 180 / M_PI;
-            if (!next) a = -a;
-            if (a <= kSpinAhead) a += 360;
-            if (!found || a < best) best = a, found = true;
-        }
-        if (!found || best >= 360 - kSpinAhead) {
-            if (!g_spin.on) g_spin.base.clear();
-            return (void)std::snprintf(reply, size, "ok 0 (no other panel)");
-        }
-        if (best > 180) best -= 360;  // the short way round
-        turn = next ? best : -best;
-    } else {
-        char *end;
-        turn = std::strtod(arg, &end);
-        if (end == arg || *end) return (void)std::snprintf(reply, size, "error spin next|prev|<degrees>");
-    }
-    g_spin.to += turn * M_PI / 180;
-    g_spin.start = Clock::now();
-    g_spin.on = true;
-    SendPointer("recenter");  // the 3D mouse's pointer stays in front of you, on what comes there
-    std::snprintf(reply, size, "ok %.1f", turn);
-}
-
 uint32_t LinuxButton(uint32_t vrButton) {
    switch (vrButton) {
        case vr::VRMouseButton_Right: return BTN_RIGHT;
@@ -1677,81 +1514,6 @@ void ReleaseAwayBy(vr::TrackedDeviceIndex_t dev, uint32_t vrButton, void (*handl
    if (g_press.buttons && dev == g_press.device) ReleaseAway(LinuxButton(vrButton), handle, data);
 }

-// Where a laser meets a panel's surface, in the panel's u (metres along it from the centre,
-// along the arc when curved) and v (up). OpenVR curves a screen into a cylinder toward its
-// front, centred `curve` metres in front of it (see OnSurface).
-bool RayOnSurface(const Screen &s, const Mat &p, const Mat &laser, double *u, double *v) {
-    const Mat inv = Inverse(p);
-    const double o[3] = {inv.m[0][0] * laser.m[0][3] + inv.m[0][1] * laser.m[1][3] + inv.m[0][2] * laser.m[2][3] + inv.m[0][3],
-                         inv.m[1][0] * laser.m[0][3] + inv.m[1][1] * laser.m[1][3] + inv.m[1][2] * laser.m[2][3] + inv.m[1][3],
-                         inv.m[2][0] * laser.m[0][3] + inv.m[2][1] * laser.m[1][3] + inv.m[2][2] * laser.m[2][3] + inv.m[2][3]};
-    double d[3];
-    for (int i = 0; i < 3; ++i) d[i] = -(inv.m[i][0] * laser.m[0][2] + inv.m[i][1] * laser.m[1][2] + inv.m[i][2] * laser.m[2][2]);
-    if (s.curve <= 0) {
-        if (std::fabs(d[2]) < 1e-6) return false;
-        const double t = -o[2] / d[2];
-        if (t <= 0) return false;
-        *u = o[0] + d[0] * t, *v = o[1] + d[1] * t;
-        return true;
-    }
-    // x^2 + (z - r)^2 = r^2, on the screen's side of the axis (z < r).
-    const double r = s.curve, oz = o[2] - r;
-    const double a = d[0] * d[0] + d[2] * d[2], b = 2 * (o[0] * d[0] + oz * d[2]), c = o[0] * o[0] + oz * oz - r * r;
-    const double disc = b * b - 4 * a * c;
-    if (a < 1e-9 || disc < 0) return false;
-    for (double t : {(-b - std::sqrt(disc)) / (2 * a), (-b + std::sqrt(disc)) / (2 * a)}) {
-        const double x = o[0] + d[0] * t, z = oz + d[2] * t;
-        if (t <= 0 || z >= 0) continue;
-        *u = r * std::atan2(x, -z), *v = o[1] + d[1] * t;
-        return true;
-    }
-    return false;
-}
-
-// Where the mode leaves the controllers to a VR game (see the top): a hand controller
-// pointing at a panel, its controls, or a floating window's popups keeps that panel's laser
-// on (UpdateLasers) until kAimLinger ticks after it points away, like SteamVR's own floating
-// windows. Leaving takes a wider margin than arriving, and a drag or a held button keeps it
-// on. The keyboard is one overlay, so SteamVR's own intersection test does there.
-void UpdateAim() {
-    if (LasersByMode()) return;
-    std::vector<Mat> lasers;
-    for (vr::TrackedDeviceIndex_t i = 1; i < vr::k_unMaxTrackedDeviceCount; ++i) {
-        Mat d;
-        if (IsHandController(i) && LaserPose(i, &d)) lasers.push_back(d);
-    }
-    for (auto &[index, s] : g_screens) {
-        Mat p;
-        if (!s.visible || !ScreenPose(s, &p)) continue;
-        if (s.drag != Drag::None || (g_press.buttons && g_press.screen == index)) {
-            s.aimUntil = g_tick + kAimLinger;
-            continue;
-        }
-        const double m = s.grip * (g_tick < s.aimUntil ? 2.0 : 0.25), h = s.heightMetres();
-        // The panel and its controls: the bar row under it, the resize tab off its corner.
-        const double halfW = std::max(s.metres / 2 + s.grip, s.chrome / 2 + s.chrome * 0.12 + s.grip * 2) + m;
-        const double top = h / 2 + m, bottom = std::min(BarY(s) - s.grip, -(h / 2 + s.grip)) - m;
-        for (const Mat &l : lasers) {
-            double u, v;
-            if (!RayOnSurface(s, p, l, &u, &v)) continue;
-            bool on = std::fabs(u) <= halfW && v <= top && v >= bottom;
-            for (const auto &[k, sub] : s.subs) {
-                if (on || s.cropW <= 0) break;
-                const double su = (sub.x + sub.w / 2.0 - (s.cropX + s.cropW / 2.0)) * s.mpp;
-                const double sv = -(sub.y + sub.h / 2.0 - (s.cropY + s.cropH / 2.0)) * s.mpp;
-                on = std::fabs(u - su) <= sub.w * s.mpp / 2 + m && std::fabs(v - sv) <= sub.h * s.mpp / 2 + m;
-            }
-            if (on) {
-                s.aimUntil = g_tick + kAimLinger;
-                break;
-            }
-        }
-    }
-    if (keyboard::Shown())
-        for (const Mat &l : lasers)
-            if (keyboard::Aimed(l)) g_keyboardAimUntil = g_tick + kAimLinger;
-}
-
 const char *LasersName() {
    switch (g_lasers) {
        case Lasers::Always: return "always";
@@ -2274,7 +2036,6 @@ void ft_vr_poll(void (*handle)(const struct ft_event *, void *), void *data) {
        if (ev.eventType == vr::VREvent_MouseButtonUp)
            ReleaseAwayBy(ev.trackedDeviceIndex, ev.data.mouse.button, handle, data);
    if (g_press.upAt >= 0 && g_tick >= g_press.upAt) ReleaseAway(BTN_LEFT, handle, data);
-    ReleaseStuck(handle, data);
    RefreshChrome();
    while (vr::VRSystem()->PollNextEvent(&ev, sizeof ev)) {
        if (ev.eventType == vr::VREvent_Quit) {
@@ -2310,19 +2071,10 @@ void ft_vr_poll(void (*handle)(const struct ft_event *, void *), void *data) {
        handle(&e, data);
    }
    ++g_tick;
-    UpdateSpin();
-    if (g_spin.front >= 0) {
-        ft_event e{};
-        e.type = FT_FRONT;
-        e.screen = g_spin.front;
-        g_spin.front = -1;
-        handle(&e, data);
-    }
    UpdateGame();
    UpdateArrange();
    UpdateVisibility();
    UpdateAttention();
-    UpdateAim();
    UpdateLasers();
    UpdateControls();
    UpdateGuides();
@@ -2349,7 +2101,7 @@ bool ft_vr_keyboard_show(int index) {
    const double fx = -head.m[0][2], fz = -head.m[2][2], n = std::sqrt(fx * fx + fz * fz) + 1e-9;
    const double at[3] = {head.m[0][3] + fx / n * kKeyboardAhead, head.m[1][3] - kKeyboardBelow,
                          head.m[2][3] + fz / n * kKeyboardAhead};
-    keyboard::SetLasers(LasersByMode());
+    keyboard::SetLasers(g_lasers == Lasers::Always || (g_lasers == Lasers::OutsideGames && !g_gameRunning));
    g_steamInFront = SteamInFront();
    if (g_steamInFront) {
        g_asidePose = FacingPose(at, head);
@@ -2394,8 +2146,6 @@ void ft_vr_keyboard_hide(void) {
 //                             ~100 ms (it landed on something else), KWin gets it anyway
 //   state         -> "ok <mode> <manual 0|1> <wrist deg> <gesture hand> <gesture deg>
 //                     <controllers> <game running 0|1> <ingames>"
-//   spin next|prev|<degrees>  turn every panel in the room about your head (see the lazy
-//                             susan) -> "ok <degrees turned>"
 //   cutouts on|off|state      hand cutouts (see handcut.h) -> "ok <on|off> <ready|idle|unavailable>
 //                             <last composite ms> ms, predict <on|off> lead <ms> ms"
 //   cutouts predict on|off    move the hands ahead along their velocity (on by default)
@@ -2433,7 +2183,6 @@ void ft_vr_command(const char *cmd, char *reply, int size) {
        Screen *s = Find(n);
        if (!s) return (void)std::snprintf(reply, size, "error no screen %d", n);
        EndDrag(*s);
-        g_spin.base.erase(n - 1);
        SetAbsolute(*s, PanelPose(x, y, z, yaw, pitch, roll));
        std::snprintf(reply, size, "ok");
    } else if (std::sscanf(cmd, "width %d %lf", &n, &w) == 2) {
@@ -2600,7 +2349,6 @@ void ft_vr_command(const char *cmd, char *reply, int size) {
        Mat m{};
        for (int k = 0; k < 12; ++k) m.m[k / 4][k % 4] = r[k];
        EndDrag(*s);
-        g_spin.base.erase(n - 1);
        SetAbsolute(*s, m);
        std::snprintf(reply, size, "ok");
    } else if (int k0; std::sscanf(cmd, "sub %d %d %d %d %d %d", &n, &k0, &x0, &y0, &w0, &h0) == 6 ||
@@ -2628,8 +2376,6 @@ void ft_vr_command(const char *cmd, char *reply, int size) {
        if ((g_press.buttons & ButtonBit(BTN_LEFT)) && g_press.device != kNone && !IsHandController(g_press.device))
            g_press.upAt = g_tick + 9;
        std::snprintf(reply, size, "ok");
-    } else if (std::sscanf(cmd, "spin %15s", word) == 1) {
-        SpinCommand(word, reply, size);
    } else if (std::strncmp(cmd, "state", 5) == 0) {
        std::snprintf(reply, size, "ok %s %d %.0f %s %.0f %s %d %s", ModeName(), g_manual ? 1 : 0, g_wristAngle,
                      g_gestureHand.c_str(), g_gestureAngle, LasersName(), g_gameRunning ? 1 : 0,
@@ -17,8 +17,7 @@ struct ft_dmabuf {
    int fd[4];
 };

-// FT_FRONT: a spin (the lazy susan) brought panel `screen` to straight ahead: typing goes there.
-enum ft_event_type { FT_MOTION, FT_BUTTON, FT_SCROLL, FT_LEAVE, FT_QUIT, FT_KEY, FT_KEYBOARD_CLOSED, FT_FRONT };
+enum ft_event_type { FT_MOTION, FT_BUTTON, FT_SCROLL, FT_LEAVE, FT_QUIT, FT_KEY, FT_KEYBOARD_CLOSED };

 struct ft_event {
    enum ft_event_type type;
@@ -36,10 +36,6 @@ check "distrobox" on_frame 'test -x ~/.local/bin/distrobox && ~/.local/bin/distr
 check "container $FRAME_BOX" on_frame "podman ps -a --filter name=^$FRAME_BOX\$ --format '{{.Image}} {{.Status}}' | grep ."
 check "repo on the Frame" on_frame 'pwd'
 check "free space in ~" on_frame "df -h ~ | awk 'NR==2{print \$4\" free\"}'"
-# A taskbar saved on a screen the desktop doesn't have is hidden; the desktop's next start
-# moves it to the first screen (session/fix-panels.py).
-check "taskbar on a screen" on_frame 'set -o pipefail; [ -f session/fix-panels.py ] || { echo "not checked (older checkout)"; exit 0; }
-  python3 session/fix-panels.py --check | paste -sd ";" | sed "s/;/; /g"'

 echo "what Frametop needs from SteamOS:"
 if [ "$FRAME_LOCAL" = 1 ]; then
@@ -42,25 +42,6 @@ for i, s in enumerate(d.get("screens", []), 1):
 print("visibility:", d.get("visibility"))
 PY

-section "Plasma panels and outputs"
-python3 "$repo/session/fix-panels.py" --check 2>&1 || true
-python3 - "$repo" <<'PY' 2>&1 || true
-import json, subprocess, sys
-sys.path.insert(0, sys.argv[1] + "/layout")
-import ft_layout
-env = ft_layout.nested_env()
-if not env:
-    sys.exit(print("desktop not running: no live outputs or panels"))
-outs = json.loads(subprocess.run(["kscreen-doctor", "-j"], capture_output=True, text=True, env=env, timeout=10).stdout or "{}")
-for o in outs.get("outputs", []):
-    size = o.get("size") or {}
-    print(f"output {o.get('name')}: enabled={o.get('enabled')} priority={o.get('priority')} {size.get('width')}x{size.get('height')}")
-js = "print(JSON.stringify(panels().map(p => ({id: p.id, screen: p.screen, location: p.location}))))"
-r = subprocess.run(["qdbus6", "org.kde.plasmashell", "/PlasmaShell", "org.kde.PlasmaShell.evaluateScript", js],
-                   capture_output=True, text=True, env=env, timeout=10)
-print("live panels:", (r.stdout or r.stderr).strip())
-PY
-
 section "Input relay (last 60 lines)"
 journalctl --user -u frametop-input-relay -n 60 --no-pager -o short 2>/dev/null
 section "Pointer helper (last 60 lines)"
@@ -1,143 +0,0 @@
-#!/usr/bin/env python3
-"""Bring back a taskbar that Plasma saved against a screen this desktop doesn't have.
-
-Plasma 6.2.5 ties each panel to a screen number (lastScreen in its containment), and the
-numbers rank the enabled outputs by priority: 0 is the primary screen. A panel whose
-number is past the screen count gets no view and stays hidden; Plasma never moves it,
-even on a later start (sanitizeScreenLayout() only remaps a panel whose number has no
-desktop, and the Frametop desktop keeps a desktop for every spare output it has seen).
-So a taskbar saved on a spare output (issue #18), or on a screen that a smaller layout
-dropped, was lost until the config was deleted.
-
-The session runs this before Plasma starts, so nothing races Plasma for the file. Each
-panel numbered at or past the screen count moves to screen 0, with its system tray's
-containment, and keeps its widgets and settings. A panel is left where it is when screen
-0 already has a panel on that edge: it comes back by itself if the screens do. The file
-is backed up once per repair (<file>.ft-bak), and the changes go through kwriteconfig6.
-
-  fix-panels.py [--screens N] [--file APPLETSRC] [--check]
-    --screens  the desktop's screen count (default: the configured layout's)
-    --file     default: $XDG_CONFIG_HOME/plasma-org.kde.plasma.desktop-appletsrc, with
-               XDG_CONFIG_HOME defaulting to the Frametop desktop's ~/.config/frametop
-    --check    change nothing; list the panels, and exit 1 if one is lost
-"""
-import argparse
-import os
-import re
-import shutil
-import subprocess
-import sys
-
-EDGES = {3: "top", 4: "bottom", 5: "left", 6: "right"}  # Plasma::Types::Location
-SYSTRAY = "org.kde.plasma.private.systemtray"
-GROUP = re.compile(r"\[([^\]]*)\]")
-
-
-def parse(text):
-    """KConfig text -> {(group, subgroup, ...): {key: value}}."""
-    groups, cur = {}, None
-    for line in text.splitlines():
-        line = line.strip()
-        if line.startswith("["):
-            cur = tuple(GROUP.findall(line))
-            groups.setdefault(cur, {})
-        elif cur is not None and "=" in line and not line.startswith("#"):
-            k, v = line.split("=", 1)
-            groups[cur][re.sub(r"\[\$.*\]$", "", k.strip())] = v.strip()
-    return groups
-
-
-def number(v, default=-1):
-    try:
-        return int(v)
-    except (TypeError, ValueError):
-        return default
-
-
-def panels(groups):
-    """The panels, by containment id: location, lastScreen, and the ids of their system
-    trays' own containments (which sit on the same edge and screen as the panel)."""
-    trays, found = {}, {}
-    for g, keys in groups.items():
-        if len(g) == 5 and g[0] == "Containments" and g[2] == "Applets" and g[4] == "Configuration":
-            tray = keys.get("SystrayContainmentId")
-            if tray:
-                trays.setdefault(g[1], []).append(tray)
-    owned = {t for ts in trays.values() for t in ts}
-    for g, keys in groups.items():
-        if len(g) != 2 or g[0] != "Containments" or number(g[1]) <= 0 or g[1] in owned:
-            continue
-        loc = number(keys.get("location"), 0)
-        if loc in EDGES and keys.get("plugin") != SYSTRAY:
-            found[g[1]] = {"location": loc, "screen": number(keys.get("lastScreen")),
-                           "plugin": keys.get("plugin", "?"), "trays": trays.get(g[1], [])}
-    return dict(sorted(found.items(), key=lambda kv: number(kv[0])))
-
-
-def plan(groups, screens):
-    """(moves, kept): moves are (panel id, from screen, containment ids to put on screen 0);
-    kept are (panel id, from screen, why) for lost panels left alone."""
-    found = panels(groups)
-    taken = {(p["screen"], p["location"]) for p in found.values() if 0 <= p["screen"] < screens}
-    moves, kept = [], []
-    for pid, p in found.items():
-        if p["screen"] < screens:
-            continue  # on a screen this desktop has (Plasma puts -1 on the first one itself)
-        if (0, p["location"]) in taken:
-            kept.append((pid, p["screen"], f"the first screen already has a {EDGES[p['location']]} panel"))
-            continue
-        taken.add((0, p["location"]))
-        moves.append((pid, p["screen"], [pid, *p["trays"]]))
-    return moves, kept
-
-
-def default_screens():
-    sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), "..", "layout"))
-    import ft_layout
-    return ft_layout.screen_count()
-
-
-def main(argv):
-    ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
-    ap.add_argument("--screens", type=int)
-    ap.add_argument("--file")
-    ap.add_argument("--check", action="store_true")
-    a = ap.parse_args(argv)
-    config = os.environ.get("XDG_CONFIG_HOME") or os.path.expanduser("~/.config/frametop")
-    path = a.file or os.path.join(config, "plasma-org.kde.plasma.desktop-appletsrc")
-    screens = a.screens if a.screens else default_screens()
-    try:
-        with open(path) as f:
-            groups = parse(f.read())
-    except FileNotFoundError:
-        if a.check:
-            print("no Plasma config yet (Plasma makes the default taskbar)")
-        return 0
-    moves, kept = plan(groups, screens)
-
-    if a.check:
-        found = panels(groups)
-        for pid, p in found.items():
-            lost = " (lost: no such screen)" if p["screen"] >= screens else ""
-            print(f"panel {pid}: screen {p['screen']}, {EDGES[p['location']]}{lost}")
-        if not found:
-            print("no panels")
-        print(f"{screens} screen(s)")
-        return 1 if moves or kept else 0
-
-    if moves:
-        shutil.copy2(path, path + ".ft-bak")
-    for pid, was, ids in moves:
-        for cid in ids:
-            subprocess.run(["kwriteconfig6", "--file", os.path.abspath(path), "--group", "Containments",
-                            "--group", cid, "--key", "lastScreen", "0"], check=True)
-        print(f"frametop: panel {pid} was saved on screen {was}, which this desktop doesn't have "
-              f"({screens} screen(s)); moved it to the first screen (backup: {path}.ft-bak)", file=sys.stderr)
-    for pid, was, why in kept:
-        print(f"frametop: panel {pid} is saved on screen {was}, which this desktop doesn't have; "
-              f"left there: {why}", file=sys.stderr)
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))
@@ -272,9 +272,4 @@ fi
 # with both, apps would open twice.
 kwriteconfig6 --file "$XDG_CONFIG_HOME/ksmserverrc" --group General --key loginMode emptySession

-# Plasma keeps a panel on a screen number, and never moves one whose screen this desktop
-# doesn't have, like a spare output or a screen a smaller layout dropped. Put such a panel
-# back on the first (primary) screen before Plasma reads the file (session/fix-panels.py).
-python3 "$here/fix-panels.py" --screens "$screens" || true
-
 dbus-run-session startplasma-wayland
@@ -1,162 +0,0 @@
-#!/usr/bin/env python3
-"""Tests for session/fix-panels.py: issue #18's config (the taskbar saved on spare output 8
-of a 3-screen desktop), panels that are fine, an edge that's taken, and a real run of
-kwriteconfig6 on a copy. Nothing here touches the running desktop or its config.
-
-  python3 session/tests/test_fix_panels.py
-"""
-import importlib.util
-import os
-import subprocess
-import sys
-import tempfile
-import unittest
-
-HERE = os.path.dirname(os.path.realpath(__file__))
-SCRIPT = os.path.join(HERE, "..", "fix-panels.py")
-spec = importlib.util.spec_from_file_location("fix_panels", SCRIPT)
-fp = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(fp)
-
-
-def desktop(cid, screen):
-    return f"""[Containments][{cid}]
-activityId=7e1d1a3c-0000-4000-8000-000000000000
-formfactor=0
-immutability=1
-lastScreen={screen}
-location=0
-plugin=org.kde.plasma.folder
-wallpaperplugin=org.kde.image
-"""
-
-
-def panel(cid, screen, location=4, tray=None):
-    text = f"""[Containments][{cid}]
-activityId=
-formfactor=2
-immutability=1
-lastScreen={screen}
-location={location}
-plugin=org.kde.panel
-wallpaperplugin=org.kde.image
-
-[Containments][{cid}][Applets][{cid}1]
-immutability=1
-plugin=org.kde.plasma.kickoff
-"""
-    if tray:
-        text += f"""
-[Containments][{cid}][Applets][{cid}2]
-immutability=1
-plugin=org.kde.plasma.systemtray
-
-[Containments][{cid}][Applets][{cid}2][Configuration]
-PreloadWeight=90
-SystrayContainmentId={tray}
-
-[Containments][{tray}]
-activityId=
-formfactor=2
-immutability=1
-lastScreen={screen}
-location={location}
-plugin=org.kde.plasma.private.systemtray
-popupHeight=432
-"""
-    return text
-
-
-ISSUE_18 = "\n".join([desktop(1, 0), desktop(18, 1), desktop(19, 2)] + [desktop(20 + i, 3 + i) for i in range(8)]
-                     + [panel(10, 8, tray=11), "[ScreenMapping]\nitemsOnDisabledScreens=\n"])
-
-
-class Plan(unittest.TestCase):
-    def test_issue_18(self):
-        moves, kept = fp.plan(fp.parse(ISSUE_18), 3)
-        self.assertEqual(moves, [("10", 8, ["10", "11"])])
-        self.assertEqual(kept, [])
-
-    def test_panel_on_a_screen_stays(self):
-        for screen in (0, 2, -1):
-            moves, kept = fp.plan(fp.parse(desktop(1, 0) + panel(2, screen, tray=8)), 3)
-            self.assertEqual((moves, kept), ([], []), screen)
-
-    def test_tray_is_not_a_panel(self):
-        found = fp.panels(fp.parse(panel(2, 0, tray=8)))
-        self.assertEqual(list(found), ["2"])
-        self.assertEqual(found["2"]["trays"], ["8"])
-
-    def test_desktops_never_move(self):
-        moves, _ = fp.plan(fp.parse(ISSUE_18), 1)
-        self.assertEqual([m[0] for m in moves], ["10"])
-
-    def test_edge_taken_on_first_screen(self):
-        text = panel(2, 0, tray=8) + panel(10, 8, tray=11)
-        moves, kept = fp.plan(fp.parse(text), 3)
-        self.assertEqual(moves, [])
-        self.assertEqual([k[:2] for k in kept], [("10", 8)])
-
-    def test_other_edge_is_free(self):
-        moves, kept = fp.plan(fp.parse(panel(2, 0) + panel(10, 4, location=3)), 3)
-        self.assertEqual(moves, [("10", 4, ["10"])])
-        self.assertEqual(kept, [])
-
-    def test_two_lost_on_one_edge(self):
-        moves, kept = fp.plan(fp.parse(panel(10, 5) + panel(12, 8)), 3)
-        self.assertEqual([m[0] for m in moves], ["10"])
-        self.assertEqual([k[0] for k in kept], ["12"])
-
-    def test_screen_count_went_down(self):
-        moves, _ = fp.plan(fp.parse(panel(2, 1, location=3)), 1)
-        self.assertEqual(moves, [("2", 1, ["2"])])
-
-
-class Run(unittest.TestCase):
-    def setUp(self):
-        self.dir = tempfile.TemporaryDirectory()
-        self.path = os.path.join(self.dir.name, "plasma-org.kde.plasma.desktop-appletsrc")
-        with open(self.path, "w") as f:
-            f.write(ISSUE_18)
-
-    def tearDown(self):
-        self.dir.cleanup()
-
-    def run_script(self, *args):
-        return subprocess.run([sys.executable, SCRIPT, "--file", self.path, "--screens", "3", *args],
-                              capture_output=True, text=True)
-
-    def test_check_reports_and_changes_nothing(self):
-        r = self.run_script("--check")
-        self.assertEqual(r.returncode, 1)
-        self.assertIn("panel 10: screen 8, bottom (lost", r.stdout)
-        with open(self.path) as f:
-            self.assertEqual(f.read(), ISSUE_18)
-
-    def test_repair(self):
-        r = self.run_script()
-        self.assertEqual(r.returncode, 0, r.stderr)
-        self.assertIn("moved it to the first screen", r.stderr)
-        with open(self.path) as f:
-            groups = fp.parse(f.read())
-        self.assertEqual(groups[("Containments", "10")]["lastScreen"], "0")
-        self.assertEqual(groups[("Containments", "11")]["lastScreen"], "0")
-        self.assertEqual(groups[("Containments", "10", "Applets", "101")]["plugin"], "org.kde.plasma.kickoff")
-        self.assertEqual(groups[("Containments", "25")]["lastScreen"], "8")  # a spare's desktop
-        with open(self.path + ".ft-bak") as f:
-            self.assertEqual(f.read(), ISSUE_18)
-        # A second run finds nothing to do and leaves the backup alone.
-        os.remove(self.path + ".ft-bak")
-        r = self.run_script()
-        self.assertEqual((r.returncode, r.stderr), (0, ""))
-        self.assertFalse(os.path.exists(self.path + ".ft-bak"))
-        self.assertEqual(self.run_script("--check").returncode, 0)
-
-    def test_no_config_yet(self):
-        os.remove(self.path)
-        self.assertEqual(self.run_script().returncode, 0)
-        self.assertEqual(self.run_script("--check").returncode, 0)
-
-
-if __name__ == "__main__":
-    unittest.main()
@@ -1,241 +0,0 @@
-#!/usr/bin/env bash
-# Uninstall Frametop from the Steam Frame. In a terminal on the headset (Konsole in the desktop,
-# or over SSH):
-#
-#   curl -fsSL https://deejanuz.github.io/frametop/uninstall.sh | bash
-#
-# or ~/frametop/uninstall.sh. It doesn't use the rest of the repo, so it also works when
-# ~/frametop is gone or broken.
-#
-# It never stops what you're using now: the input relay carries the keyboard and mouse, and the
-# desktop runs from the repo. So it goes in two steps:
-#   1. Frametop stops starting. The launcher's Desktop entry goes back to the stock desktop, and
-#      Frametop's services, SteamVR driver, menu entries, and system files (our eye tracker's
-#      frame grabber and the Bluetooth fixes, with sudo) are removed. What runs now keeps running
-#      until you restart the headset.
-#   2. After the restart, run it again. It deletes the code (~/frametop) and, if you want, your
-#      settings and the build container.
-# When nothing of Frametop is running, one run does both.
-#
-# Options (piped, they go after "bash -s --"):
-#   --dir DIR    where the repo is, if not ~/frametop
-#   --dry-run    show what it would do, and change nothing
-set -euo pipefail
-shopt -s nullglob
-
-usage() {
-  cat <<'EOF'
-usage: uninstall.sh [--dir DIR] [--dry-run]
-piped: curl -fsSL https://deejanuz.github.io/frametop/uninstall.sh | bash -s -- [options]
-EOF
-}
-
-dry=0
-apps=$HOME/.local/share/applications
-override=$apps/deckard-nested-desktop.desktop
-relay_unit=$HOME/.config/systemd/user/frametop-input-relay.service
-driver=$HOME/.local/share/frametop/ft_pointer
-vrpathreg=/opt/steamvr/bin/linuxarm64/vrpathreg
-handsctl=$HOME/.local/bin/ft-handsctl
-eyegrab_files=(/etc/systemd/system/frametop-eyegrab.service /etc/frametop/ft-eyegrab)
-bt_files=(/etc/systemd/system/steamframe-bt-fixups.service /etc/systemd/system/bluetooth.service.d/steamframe.conf
-          /etc/steamframe/bt-fixups.sh)
-
-step() { printf '\n\033[1m== %s\033[0m\n' "$*"; }
-run() {  # run a command, or with --dry-run, show it
-  if [ "$dry" = 1 ]; then printf '  would run: %s\n' "$*"; else "$@"; fi
-}
-ask() {  # ask "question" default(y|n)
-  local hint answer
-  if [ "$dry" = 1 ]; then echo "$1 [dry run: yes]"; return 0; fi
-  hint=$([ "$2" = y ] && echo "Y/n" || echo "y/N")
-  read -r -p "$1 [$hint] " answer </dev/tty || answer=
-  answer=${answer:-$2}
-  [[ $answer =~ ^[Yy] ]]
-}
-exists() { local f; for f in "$@"; do [ -e "$f" ] && return 0; done; return 1; }
-size() { du -shc "$@" 2>/dev/null | tail -1 | cut -f1; }
-
-# Is this folder Frametop's code? Only then is it deleted.
-is_repo() { [ "$1" != "$HOME" ] && [ -f "$1/desktops.sh" ] && [ -f "$1/session/frametop-session.sh" ]; }
-find_repo() {
-  local p
-  [ -n "$dir" ] && { echo "$dir"; return; }
-  # The launcher entry and the relay's unit point into the repo, until step 1 removes them.
-  p=$(sed -n 's#^Exec=\(.*\)/session/frametop-session\.sh.*#\1#p' "$override" 2>/dev/null | head -1)
-  [ -z "$p" ] && p=$(sed -n 's#^ExecStart=/usr/bin/python3 \(.*\)/input/input-relay\.py.*#\1#p' "$relay_unit" 2>/dev/null | head -1)
-  [ -z "$p" ] && [ -f "${BASH_SOURCE[0]:-}" ] && p=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
-  echo "${p:-$HOME/frametop}"
-}
-
-# Frametop's programs that are running now (step 1 leaves them running until the restart).
-running() {
-  local n out=()
-  for n in ft-screens ft-pointer ft-powerd ft-eyegrab ft-camd ft-hands; do
-    pgrep -x "$n" >/dev/null && out+=("$n")
-  done
-  pgrep -f '[i]nput/input-relay\.py' >/dev/null && out+=("input relay")
-  pgrep -f '[g]aze/ft-gazed' >/dev/null && out+=("gaze service")
-  pgrep -f '[f]rametop-session\.sh' >/dev/null && out+=("desktop session")
-  echo "${out[*]}"
-}
-
-main() {
-  local units=() entries=() names=() sys=0 repo now f
-  while [ $# -gt 0 ]; do
-    case $1 in
-      --dir) dir=${2:?--dir needs a folder}; shift ;;
-      --dry-run) dry=1 ;;
-      -h|--help) usage; return 0 ;;
-      *) echo "unknown option: $1" >&2; usage >&2; return 2 ;;
-    esac
-    shift
-  done
-
-  if ! { grep -qx 'ID=steamos' /etc/os-release && grep -qE '^VARIANT_ID="?vr"?$' /etc/os-release; } 2>/dev/null; then
-    echo "This uninstalls Frametop from a Steam Frame (SteamOS, VR variant). Run it in a terminal on the headset." >&2
-    return 1
-  fi
-  if [ "$dry" = 0 ] && ! { : </dev/tty; } 2>/dev/null; then
-    echo "This asks questions, and there's no terminal to ask in. Run it in one (over SSH: ssh -t)." >&2
-    return 1
-  fi
-  [ "$dry" = 1 ] && echo "Dry run: nothing changes."
-  repo=$(find_repo)
-
-  # Step 1: what makes Frametop start. Nothing here stops a running program.
-  [ -f "$override" ] && grep -q 'Frametop' "$override" || override=
-  units=("$HOME"/.config/systemd/user/frametop-*.service)
-  for f in ft-input-settings ft-display-settings ft-layout-reset ft-screens-toggle ft-remote-settings ft-gazeprobe; do
-    [ -e "$apps/$f.desktop" ] && entries+=("$apps/$f.desktop")
-  done
-  [ -e "$apps/frametop-handrec.desktop" ] && entries+=("$apps/frametop-handrec.desktop")
-  entries+=("$apps"/frametop-profile-*.desktop)  # one per layout profile (layout/ft_layout.py)
-  [ -L "$handsctl" ] || handsctl=
-  exists "${eyegrab_files[@]}" "${bt_files[@]}" && sys=1
-
-  if [ -n "$override" ] || [ ${#units[@]} -gt 0 ] || [ ${#entries[@]} -gt 0 ] || [ -d "$driver" ] ||
-     [ -n "$handsctl" ] || [ "$sys" = 1 ]; then
-    step "Step 1 of 2: stop Frametop from starting"
-    echo "This removes:"
-    [ -n "$override" ] && echo "  - the launcher's Desktop entry (Launch a program -> Desktop opens the stock desktop again)"
-    for f in "${units[@]}"; do echo "  - the service $(basename "$f")"; done
-    [ -d "$driver" ] && echo "  - the 3D mouse's SteamVR driver (ft_pointer)"
-    [ ${#entries[@]} -gt 0 ] && echo "  - ${#entries[@]} menu entries (Frametop Display Settings, Input Settings, ...)"
-    [ -n "$handsctl" ] && echo "  - $handsctl"
-    exists "${eyegrab_files[@]}" && echo "  - our eye tracker's frame grabber (a system service: needs your password)"
-    exists "${bt_files[@]}" && echo "  - the Bluetooth fixes (system files: needs your password)"
-    echo "What runs now keeps running until you restart the headset, so your keyboard, mouse, and"
-    echo "this terminal keep working. Your settings and the code stay for now."
-    ask "Uninstall Frametop?" n || { echo "Nothing changed."; return 0; }
-
-    [ -n "$override" ] && run rm -f "$override"
-    if [ ${#units[@]} -gt 0 ]; then
-      for f in "${units[@]}"; do names+=("$(basename "$f")"); done
-      run systemctl --user disable "${names[@]}" 2>/dev/null || true
-      run rm -f "${units[@]}"
-      run systemctl --user daemon-reload
-    fi
-    if [ -d "$driver" ]; then
-      if [ -x "$vrpathreg" ]; then
-        LD_LIBRARY_PATH=$(dirname "$vrpathreg") run "$vrpathreg" removedriver "$driver" ||
-          echo "warning: SteamVR's vrpathreg couldn't unregister the driver; SteamVR may log that it's missing" >&2
-      fi
-      run rm -rf "$driver"
-    fi
-    [ ${#entries[@]} -gt 0 ] && run rm -f "${entries[@]}"
-    [ -n "$handsctl" ] && run rm -f "$handsctl"
-    if [ "$sys" = 1 ]; then
-      echo "The system files need your password (sudo)."
-      if ! run sudo bash -c '
-        for u in frametop-eyegrab steamframe-bt-fixups; do systemctl disable $u.service 2>/dev/null; done
-        rm -f "$@"
-        rmdir /etc/frametop /etc/steamframe /etc/systemd/system/bluetooth.service.d 2>/dev/null
-        systemctl daemon-reload; true' sys "${eyegrab_files[@]}" "${bt_files[@]}"; then
-        echo "warning: the system files weren't removed (no password?). Run this again to retry." >&2
-      fi
-    fi
-    [ "$dry" = 1 ] || echo "Frametop no longer starts."
-  fi
-
-  # Step 2: delete what's left, once nothing of Frametop runs.
-  now=$(running)
-  if [ -n "$now" ]; then
-    step "Restart the headset to finish"
-    echo "Still running from before: $now."
-    echo "They stop when the headset restarts. After that, run this again to delete the code"
-    echo "($repo) and, if you want, your settings and the build container:"
-    echo
-    if [ "$repo" = "$HOME/frametop" ]; then
-      echo "  curl -fsSL https://deejanuz.github.io/frametop/uninstall.sh | bash"
-    else
-      echo "  curl -fsSL https://deejanuz.github.io/frametop/uninstall.sh | bash -s -- --dir $(printf %q "$repo")"
-    fi
-    echo
-    if ask "Restart the headset now? This closes everything open, in VR and on the desktop." n; then
-      run systemctl reboot || echo "Couldn't restart it from here: restart the headset from Steam's power menu." >&2
-    fi
-    [ "$dry" = 1 ] || return 0
-    echo "Dry run: after the restart, step 2 would go like this."
-  fi
-
-  step "Step 2 of 2: delete what's left"
-  if [ -d "$repo" ] && is_repo "$repo"; then
-    if [ -f "$repo/.git" ]; then
-      echo "Leaving $repo: it's a git worktree. Remove it with git worktree remove."
-    else
-      local def=y
-      if [ -n "$(git -C "$repo" status --porcelain --untracked-files=no 2>/dev/null)" ] ||
-         [ -n "$(git -C "$repo" log --branches --not --remotes --oneline 2>/dev/null | head -1)" ]; then
-        echo "$repo has changes of its own (git -C $repo status)."
-        def=n
-      fi
-      if ask "Delete the Frametop code in $repo ($(size "$repo"))?" "$def"; then
-        cd "$HOME"
-        run rm -rf "$repo"
-      fi
-    fi
-  elif [ -e "$repo" ]; then
-    echo "Leaving $repo: it doesn't look like Frametop's code."
-  fi
-
-  # Rebuilt by the desktop at each start, so nothing to keep.
-  run rm -rf "$HOME/.local/share/frametop/apps" "$HOME/.local/share/kwin/decorations/kwin4_decoration_qml_frametop" \
-    "$HOME/.cache/frametop"
-
-  local settings=("$HOME"/.config/frametop.conf* "$HOME"/.config/frametop-*.json* "$HOME/.config/frametop-remote"
-                  "$HOME/.config/frametop" "$HOME/.local/state/frametop")
-  local kept=()
-  for f in "${settings[@]}"; do [ -e "$f" ] && kept+=("$f"); done
-  if [ ${#kept[@]} -gt 0 ]; then
-    echo "Your settings: the screen layout and profiles, button maps, gaze calibration, the remote"
-    echo "desktop password, and the Frametop desktop's own Plasma setup (${kept[*]/#$HOME/\~})."
-    ask "Delete your settings too? Keep them to pick up where you left off if you reinstall." n &&
-      run rm -rf "${kept[@]}"
-  fi
-
-  local recs=()
-  for f in "$HOME/.local/share/frametop/eyes" "$HOME/.local/share/frametop/hands"; do [ -e "$f" ] && recs+=("$f"); done
-  if [ ${#recs[@]} -gt 0 ]; then
-    ask "Delete your eye and hand recordings in ~/.local/share/frametop ($(size "${recs[@]}"))?" n &&
-      run rm -rf "${recs[@]}"
-  fi
-  [ "$dry" = 1 ] || rmdir "$HOME/.local/share/frametop" 2>/dev/null || true
-
-  if command -v podman >/dev/null && podman container exists dev 2>/dev/null; then
-    echo "The build container (dev) holds Frametop's compilers and libraries, 1-2 GB. If you put"
-    echo "anything else in it, that goes too."
-    if ask "Delete the build container?" n; then
-      run "$HOME/.local/bin/distrobox" rm --force dev </dev/null
-      run podman image rm registry.fedoraproject.org/fedora-toolbox:44 >/dev/null 2>&1 || true
-      echo "distrobox stays in ~/.local/bin, for any other containers. To remove it too:"
-      echo "  ~/dev/src/distrobox/uninstall --prefix ~/.local"
-    fi
-  fi
-
-  step "Done"
-  echo "Frametop is uninstalled."
-}
-
-dir=
-main "$@"