Session: AT-SPI watcher checks its buses every 5 seconds

Each check starts two gdbus processes (about 5.5 ms of CPU each on the
Frame), so checking once a second cost about 1% of a core for as long as
the desktop ran. On SteamOS 0.3.0 native activation fails, so the watcher
always runs. A registry left behind now goes within 5 seconds instead of 1.

design.md also says where the watcher matters: started from the VR
launcher, the desktop runs in steam.service, which doesn't stop with it,
so keep-apps.sh and the unit's stop don't clean up there.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

docs/design.md

@@ -133,7 +133,7 @@ A few overlays need special handling:
 
 Head follow is experimental and off by default. It works, but it's only lightly tested, and the feel is mostly a matter of its settings; polishing it is left open. With it on (`POINTER_FOLLOW=1`, or a mouse button mapped to Head follow on/off), the cursor rides on a reference direction, where you were facing when your head last settled, and keeps its offset from it. The mouse can put the cursor anywhere up to `POINTER_FOLLOW_REACH` (70 degrees) from the reference, a corner of your view included. While your head stays within `POINTER_LEASH_DEG` of the reference, nothing moves on its own. Once your head has been past the leash for `POINTER_LEASH_DELAY` (0.2 s, so a glance out and back doesn't count), the reference eases to where you're facing (time constant `POINTER_LEASH_RETURN`, 0.2 s), never falling further behind than the leash, and the cursor ends up back where it was in your view. Then it waits for the leash again. Two earlier versions didn't work out. Moving the reference only while your head pulled at the end of the leash left it up to the leash off after you turned back, and getting it centred again meant overshooting with your head. Easing it toward your facing all the time moved the cursor on every small head movement. A leash of 0 makes the reference your facing direction, so the cursor is locked to your view, and mouse movement shifts it within the view. Head roll is ignored, so tilting your head doesn't swing the cursor around. While the left button is held the cursor stays put in the room, so your head can't nudge a click or a drag. When you let go, it carries on from where it is instead of jumping.
 
-Gaze mode is experimental and off by default (`POINTER_GAZE=1`, the Gaze page of Frametop Input Settings, `gaze/ft-gazectl on`, or a mouse button or key combination mapped to Gaze pointer on/off). It's MAGIC pointing (Zhai, Morimoto and Ihde, 1999): the pointer goes where you look, and the mouse does the last bit. The gaze service (`gaze/ft-gazed`) sends the helper the corrected gaze at 90 Hz (from one eye while the tracker has lost the other), and while the gaze has the pointer, the cursor ray is that gaze from the eye. The pointer is aimed at the gaze each frame, not steered toward it, so nothing can pile up. An earlier try in the gaze probe steered the pointer with relative moves, and lost it when the pointer went idle or a controller had the laser. By default (`POINTER_GAZE_MOUSE_MOVE=held`, the Gaze page's Mouse movement switch) moving the mouse does nothing while the gaze has the pointer: it moves the pointer only while a button is held, as a correction. A bumped or drifting mouse can't pull the pointer off what you're looking at, and every mouse move is a correction, so the lessons aren't polluted by mouse moves to somewhere else (they used to be kept out by an 8 degree limit, which also dropped real corrections when the tracker was further off). With the gaze stale for a second, in a game, or with the headset off, the mouse moves the pointer as usual; with `free`, moving the mouse takes the pointer from the gaze. A left press while the gaze has the pointer isn't sent at once: the pointer stops where the gaze put it, you drag it onto what you meant with the button still down (panels only see it hover), and the release clicks there. Clicking at once clicked wherever the gaze was, often the wrong thing, before you could correct it. The drag is the correction. Snapping the pointer onto buttons and links is deferred: it needs accessibility (AT-SPI) on in the Frametop session, where it's off (no registry runs), plus app restarts, and it makes Chromium and Electron apps use more CPU. A press held still for `POINTER_GAZE_HOLD` (0.5 s) becomes a real press, so drags still work: hold, then move. The right button works the same way, with the right click on the release, and pressing it while the left press is held back starts a drag where the pointer is, like Meta+J then Meta+K. That drag lasts while either button (or key) is held, so a second right press, or a second Meta+K, is free to pan and tilt the panel being dragged; with the keyboard, the head turns it. Outside games the pointer then stays: the mouse going idle doesn't release it. A moving controller still releases it, as without gaze. Gaze mode is a mouse and keyboard feature: Steam reads the Frame controllers itself, outside SteamVR's bindings, so controller clicks at the gaze kept knocking SteamVR out of laser mode (see `docs/gaze-controllers.md`). Keyboard clicks (Meta+J, Meta+K) hold the dot still in your view while the keys are down, so the head, not the mouse, does the last bit; a quick tap clicks where the dot was at the press, since the head moves as you hit the keys. The relay hides Meta from the desktop as soon as such a combination fires, because KWin takes Meta with a mouse button as a window move or resize, which swallowed the clicks. The dot shows all the time by default. With `POINTER_GAZE_DOT=moving` it shows only while the mouse moves it (`POINTER_GAZE_SHOW`), while a press is held, and as a pulse for each click; otherwise it's transparent, so the laser still lands on it. Looking more than `POINTER_GAZE_RETAKE` (5 degrees) away from it, with the mouse still, gives it back, so small eye movements around the pointer don't pull it off what you're doing. A mouse nudge before a click whose correction is within `POINTER_GAZE_NUDGE_MAX` (55 degrees, half of what the headset shows across) is sent to the gaze service as a lesson: you were looking at where you clicked when the mouse took over, so the nudge is the eye tracker's error there. Using it is what calibrates it. A one-dot check in a panel fixed to the headset tops that up when the headset goes on, when our tracker thinks it moved, and when a correction is past that limit (the tracker is far off, so a click there isn't trusted as a lesson), and the full calibration and the headset fit check run in the same panel, so everything a user does to calibrate happens in one place in the headset; the gaze probe, a fullscreen GTK app, is the development tool. The limit was 8 degrees, which dropped every correction while our tracker was 12 off. Its dots sit at known directions from the headset, so the panel needs no screen geometry. The quick check's dot takes the gaze once it has held still, so what the tracker says doesn't have to be close for the capture to work. The full calibration's and the five-dot check's dots wait for a click while you look at the dot (a left click or Meta+J), because a steady gaze isn't always on the dot, and take the gaze held still up to the click; a right click or MetLine truncated
+Gaze mode is experimental and off by default (`POINTER_GAZE=1`, the Gaze page of Frametop Input Settings, `gaze/ft-gazectl on`, or a mouse button or key combination mapped to Gaze pointer on/off). It's MAGIC pointing (Zhai, Morimoto and Ihde, 1999): the pointer goes where you look, and the mouse does the last bit. The gaze service (`gaze/ft-gazed`) sends the helper the corrected gaze at 90 Hz (from one eye while the tracker has lost the other), and while the gaze has the pointer, the cursor ray is that gaze from the eye. The pointer is aimed at the gaze each frame, not steered toward it, so nothing can pile up. An earlier try in the gaze probe steered the pointer with relative moves, and lost it when the pointer went idle or a controller had the laser. By default (`POINTER_GAZE_MOUSE_MOVE=held`, the Gaze page's Mouse movement switch) moving the mouse does nothing while the gaze has the pointer: it moves the pointer only while a button is held, as a correction. A bumped or drifting mouse can't pull the pointer off what you're looking at, and every mouse move is a correction, so the lessons aren't polluted by mouse moves to somewhere else (they used to be kept out by an 8 degree limit, which also dropped real corrections when the tracker was further off). With the gaze stale for a second, in a game, or with the headset off, the mouse moves the pointer as usual; with `free`, moving the mouse takes the pointer from the gaze. A left press while the gaze has the pointer isn't sent at once: the pointer stops where the gaze put it, you drag it onto what you meant with the button still down (panels only see it hover), and the release clicks there. Clicking at once clicked wherever the gaze was, often the wrong thing, before you could correct it. The drag is the correction. Snapping the pointer onto buttons and links is deferred: the session now starts an AT-SPI registry, but apps still need to expose useful accessibility trees (and may need restarting), and it makes Chromium and Electron apps use more CPU. A press held still for `POINTER_GAZE_HOLD` (0.5 s) becomes a real press, so drags still work: hold, then move. The right button works the same way, with the right click on the release, and pressing it while the left press is held back starts a drag where the pointer is, like Meta+J then Meta+K. That drag lasts while either button (or key) is held, so a second right press, or a second Meta+K, is free to pan and tilt the panel being dragged; with the keyboard, the head turns it. Outside games the pointer then stays: the mouse going idle doesn't release it. A moving controller still releases it, as without gaze. Gaze mode is a mouse and keyboard feature: Steam reads the Frame controllers itself, outside SteamVR's bindings, so controller clicks at the gaze kept knocking SteamVR out of laser mode (see `docs/gaze-controllers.md`). Keyboard clicks (Meta+J, Meta+K) hold the dot still in your view while the keys are down, so the head, not the mouse, does the last bit; a quick tap clicks where the dot was at the press, since the head moves as you hit the keys. The relay hides Meta from the desktop as soon as such a combination fires, because KWin takes Meta with a mouse button as a window move or resize, which swallowed the clicks. The dot shows all the time by default. With `POINTER_GAZE_DOT=moving` it shows only while the mouse moves it (`POINTER_GAZE_SHOW`), while a press is held, and as a pulse for each click; otherwise it's transparent, so the laser still lands on it. Looking more than `POINTER_GAZE_RETAKE` (5 degrees) away from it, with the mouse still, gives it back, so small eye movements around the pointer don't pull it off what you're doing. A mouse nudge before a click whose correction is within `POINTER_GAZE_NUDGE_MAX` (55 degrees, half of what the headset shows across) is sent to the gaze service as a lesson: you were looking at where you clicked when the mouse took over, so the nudge is the eye tracker's error there. Using it is what calibrates it. A one-dot check in a panel fixed to the headset tops that up when the headset goes on, when our tracker thinks it moved, and when a correction is past that limit (the tracker is far off, so a click there isn't trusted as a lesson), and the full calibration and the headset fit check run in the same panel, so everything a user does to calibrate happens in one place in the headset; the gaze probe, a fullscreen GTK app, is the development tool. The limit was 8 degrees, which dropped every correction while our tracker was 12 off. Its dots sit at known directions from the headset, so the panel needs no screen geometry. The quick check's dot takes the gaze once it has held still, so what the tracker says doesn't have to be close for the capture to work. The full calibration's and the five-dot check's dots wait for a click while you look at the dot (a left click or Meta+J), because a steady gaze isn't always on the dot, and take the gaze held still up to the click; a rightLine truncated
 
 Replacing a loaded driver's files, as re-running the installer used to do, leaves SteamVR honoring the virtual controller's hand role but not its laser claim: the dashboard pointer stays unassigned until SteamVR restarts. The driver installer now leaves an unchanged driver in place.
 
@@ -173,6 +173,18 @@ The session is modeled on SteamOS's `steamos-nested-desktop` and runs beside it.
 
 The VR launcher starts the session from the Steam client, and the client's environment came along: `LD_LIBRARY_PATH` pointing at Steam's own runtime, whose `libavcodec` has no H.264 decoder, so VLC in the desktop couldn't play most videos, plus the client's overlay and launch settings. The session script drops the client's variables before it starts anything. SteamOS's global Mesa settings (`/usr/share/deckard/mesavars.sh`) stay, and the gamescope session's Vulkan layer (`ENABLE_GAMESCOPE_WSI`) is only kept for the gamescope backend.
 
+### Nested accessibility
+
+The session drops an inherited `AT_SPI_BUS_ADDRESS`, so apps cannot accidentally use the host desktop's registry. It autostarts `session/ft-atspi` in Plasma phase 2, after KWin has set the nested display environment. The helper gets the live accessibility address from `org.a11y.Bus` on the private session bus, preserves any existing registry owner, updates the accessibility bus's activation environment, and tries `StartServiceByName` first.
+
+On SteamOS 0.3.0 with at-spi2-core 2.52.0, the native launcher can choose dbus-broker because its process belongs to a systemd user unit. Registry activation then fails: this desktop's private session bus does not have a systemd activation manager. In that case the helper starts only `at-spi2-registryd` on the already-existing accessibility bus. The registry refuses duplicate ownership. Unlike native activation's `--use-gnome-session`, the fallback does not try to register with GNOME's session manager; that flag did not explain the observed native activation failure.
+
+The fallback registry does not exit merely when its bus disconnects in the isolated SteamOS test. Its small watcher checks both private buses every 5 seconds, and terminates and reaps only the child it started when either bus disappears or the watcher is stopped. Each check runs `gdbus` twice; once a second, that cost about 1% of a core. `keep-apps.sh` keeps the watcher in the desktop unit when `desktops.sh start` runs the desktop as `frametop-desktop`. Started from the VR launcher, the desktop runs in steam.service, which doesn't stop with it, so there the watcher is the only thing that stops the registry. There is no second accessibility bus, global systemd environment update, process-name kill, or host registry replacement. Missing accessibility files or bus errors are nonfatal; the desktop still starts. Toolkit-specific accessibility opt-ins and pointer snapping are separate work.
+
+Run the isolated checks on the host with `/usr/bin/python3 session/test/test_accessibility.py`. They use private D-Bus buses, Xvfb and a GTK3 app, never the production display or input. Native activation uses a small `org.a11y.Bus` test provider pointing to a real private dbus-daemon with the installed registry service; the SteamOS fallback uses the installed bus launcher and broker. The tests check real app-tree discovery, existing owners, concurrent starts, session stop/restart, and teardown. They require test-only PyGObject (Gio and GTK3), Xvfb, and at-spi2-core; the runtime helper uses Python's standard library and the existing host `gdbus`. Actual Plasma autostart and VR desktop restart still require an approved hardware test.
+
+### Other session behavior
+
 Steam, not systemd, suspends the Frame: after `system_idle_suspend_ac_sec` (an hour by default) without input on AC power, it logs `Switching to power state: k_ESystemPowerState_Sleep` and suspends, even while charging. It's a Steam setting (Settings → Power → When Plugged In and Idle → Sleep after), which the Stay awake while plugged in switch in Frametop Display Settings sets to Never. SteamVR's standby, which turns the displays off when the headset comes off, is separate; see below.
 
 Flatpak apps need `XDG_DATA_DIRS` to include Flatpak's exports, or Plasma opens Discover instead of launching them, so the session sources `/etc/profile.d/flatpak.sh`.

docs/reference.md

@@ -18,6 +18,8 @@ desktops.sh start | stop | restart | status | log [lines]
 
 When the VR launcher starts the desktop, it inherits the Steam client's environment. The session script drops the client's runtime from it (`LD_LIBRARY_PATH`, the `STEAM_*` settings, and the Steam overlay's Vulkan layer), so apps in the desktop use the system's libraries, including its video codecs, just as they would after a normal login.
 
+The nested session also starts an AT-SPI accessibility registry through `session/ft-atspi` in Plasma's autostart. It discovers the bus from this session, ignores an inherited host accessibility address, and leaves an existing registry alone. Accessibility errors do not stop the desktop. This supplies the registry infrastructure for apps that expose AT-SPI trees; it does not enable gaze snapping or force Chromium/Electron accessibility. After an approved desktop restart, an AT-SPI-aware app should be visible on the nested bus. See [design.md](design.md#nested-accessibility) for native activation, fallback lifecycle, and the isolated test command.
+
 KWin's blur and background contrast effects and its animations are off in this desktop, because KWin draws on the headset's GPU, which SteamVR needs. The session script turns them off once, the first time it starts (it leaves a setting you already have alone, and marks it done in `~/.config/frametop/frametoprc`), so turning them back on sticks. In the Frametop desktop, System Settings → Window Management → Desktop Effects has Blur and Background Contrast, and General Behavior has Animation speed. Or from a terminal, then restart the desktop:
 
 ```

framedrop/README.md

@@ -1,59 +0,0 @@
-# Install with FrameDrop (proof of concept)
-
-[FrameDrop](https://framedropvr.com) is a Windows app that sideloads onto a Steam Frame: it copies a build to the headset and adds it to the Steam library. Issue #25 asks for an "Install with FrameDrop" button. Frametop isn't an app FrameDrop can copy over as is: it builds in a container, installs user services and a SteamVR driver, and asks questions in a terminal. So FrameDrop installs a small installer instead. Playing "Frametop" from the library runs the one-line installer (`get.sh --yes`) and shows its progress.
-
-Nothing here is published yet: no release asset, no manifest on Pages, no button.
-
-## How FrameDrop installs a Linux zip
-
-It uses Valve's SteamOS Devkit path: pair once with the headset's devkit service, then rsync the unpacked zip into `~/devkit-game/<name>` over SSH, and register it with Steam as a Devkit Game with a start command. `devkit.sh` here makes the same calls with Valve's devkit-utils, so all of this can be tested on the Frame without a PC.
-
-## What the probe found (SteamOS 0.3.0, build 20260922.6101926)
-
-`probe/probe.sh`, started as a Devkit Game, recorded:
-
-- Devkit titles run on the host, not in a container, as user `steamos`, from a process tree that Steam's reaper owns. This held even with the compat tool set to `SteamLinuxRuntime_4-arm64`: Steam recorded the mapping and still ran it on the host.
-- On the host, everything the installer needs works: git, curl to GitHub, podman (sees the `dev` container), `systemctl --user`, `systemd-run --user`, and GTK 4 with libadwaita.
-- A GTK window opens in gamescope (an X11 window on `:1`, drawn through gamescope's Vulkan WSI).
-- Steam puts its overlay in `LD_PRELOAD` and Steam runtime paths in `LD_LIBRARY_PATH` and `PATH`. Every host tool prints a preload error unless they're cleared.
-- Inside the Steam Linux Runtime 4 container (started by hand with its `run` script), there's no git, podman, systemctl, or GTK, but `flatpak-spawn --host` runs commands on the host.
-- Steam refuses Devkit Game names with a `-` ("missing/invalid arguments").
-- Steam doesn't make the start command executable: without the exec bit, the title exits in a second and nothing runs.
-
-## The installer
-
-`installer/frametop-install.sh` is the start command.
-
-1. In the container, it starts itself again on the host with `flatpak-spawn --host`.
-2. It clears Steam's preload and library paths.
-3. It runs `curl get.sh | bash -s -- --yes` in a transient user service, `frametop-framedrop-install`, unless one is already running. The service is used because Steam ends the title's whole process tree when it's quit, and starts it with an OOM score of 900.
-4. `installer/progress.py` (GTK 4 and libadwaita) follows the service's log, shows `install.sh`'s steps as a progress bar, and reports the result. Closing it leaves the install running. Playing the title again reattaches.
-
-`--yes` keeps the version that's installed, or installs stable. It skips the parts that need sudo (our eye tracker and the Bluetooth fixes) and the SteamVR restart. The window says to restart SteamVR.
-
-`--dry-run` clones into `~/.cache/frametop-framedrop/dry-run` and stops there (`get.sh --clone-only`).
-
-## Try it on the Frame
-
-```
-framedrop/devkit.sh add FrametopTest framedrop/installer "./frametop-install.sh --dry-run"
-framedrop/devkit.sh run FrametopTest        # or Play it from the Steam library
-framedrop/devkit.sh remove FrametopTest
-framedrop/devkit.sh add FrametopProbe framedrop/probe "./probe.sh native"   # the probe
-```
-
-The probe writes `~/.cache/frametop-framedrop/probe-native.log`, and the installer writes `~/.cache/frametop-framedrop/install.log`.
-
-## Build the download
-
-```
-framedrop/build.sh [ZIP_URL]
-```
-
-This writes `framedrop/build/Frametop.zip` (reproducible) and `frametop.framedrop.json`, FrameDrop's manifest with the zip's sha256. By default, `ZIP_URL` points at a `framedrop-installer` release asset. The button's link would be `https://framedropvr.com/install?manifest=https://deejanuz.github.io/frametop/frametop.framedrop.json`, with the manifest committed to main for Pages.
-
-## Open questions, for a test with FrameDrop on a Windows PC
-
-- Does FrameDrop keep or set the exec bit on `frametop-install.sh`? A zip unpacked on Windows loses it, and without it nothing runs.
-- What start command does FrameDrop pick for this zip, and which runtime?
-- Does the manifest's `name` become the Devkit Game name? It has to stay free of `-`.

framedrop/build.sh

@@ -1,39 +0,0 @@
-#!/usr/bin/env bash
-# Build the FrameDrop download: framedrop/build/Frametop.zip (the installer in a "Frametop"
-# folder) and framedrop/build/frametop.framedrop.json, the manifest an "Install with
-# FrameDrop" button points at. The zip is reproducible: same files, same sha256.
-#
-# Usage: framedrop/build.sh [ZIP_URL]
-#   ZIP_URL  where the zip will be downloaded from (default: the framedrop-installer release)
-set -euo pipefail
-
-here=$(cd "$(dirname "$0")" && pwd)
-url=${1:-https://github.com/DeeJanuz/frametop/releases/download/framedrop-installer/Frametop.zip}
-out=$here/build
-mkdir -p "$out"
-
-python3 - "$here/installer" "$out/Frametop.zip" <<'EOF'
-import os, sys, zipfile
-src, dest = sys.argv[1:]
-with zipfile.ZipFile(dest, "w", zipfile.ZIP_DEFLATED) as z:
-    for name in ("frametop-install.sh", "progress.py"):
-        info = zipfile.ZipInfo(f"Frametop/{name}", date_time=(2026, 1, 1, 0, 0, 0))
-        info.create_system = 3  # unix, so the permissions below count
-        info.external_attr = (0o100755 if os.access(os.path.join(src, name), os.X_OK) else 0o100644) << 16
-        info.compress_type = zipfile.ZIP_DEFLATED
-        with open(os.path.join(src, name), "rb") as f:
-            z.writestr(info, f.read())
-EOF
-
-sha=$(sha256sum "$out/Frametop.zip" | cut -d' ' -f1)
-python3 - "$url" "$sha" >"$out/frametop.framedrop.json" <<'EOF'
-import json, sys
-url, sha = sys.argv[1:]
-print(json.dumps({
-    "schema": "framedrop.install/v1",
-    "name": "Frametop",
-    "files": [{"url": url, "sha256": sha}],
-}, indent=2))
-EOF
-echo "built $out/Frametop.zip ($sha)"
-echo "      $out/frametop.framedrop.json"

framedrop/devkit.sh

@@ -1,95 +0,0 @@
-#!/usr/bin/env bash
-# Do on the Frame what FrameDrop does from a PC: copy a folder into ~/devkit-game/NAME and
-# register it with Steam as a "Devkit Game" (Valve's devkit-utils, the same calls FrameDrop and
-# the SteamOS Devkit Client make over SSH). For testing the FrameDrop installer and the probe
-# without a PC. Steam must be running, and Developer Mode on.
-#
-# Usage: devkit.sh add NAME DIR COMMAND [--compat TOOL]
-#        devkit.sh run NAME       # start it, as the library's Play button does
-#        devkit.sh remove NAME    # delete the folder and the Steam entry
-#        devkit.sh list
-#
-# NAME can't contain "-": Steam answers "missing/invalid arguments". COMMAND is relative to
-# the folder, like FrameDrop's start command ("./probe.sh native"). --compat sets the runtime
-# (SteamLinuxRuntime_4-arm64, say); on SteamOS 0.3.0 Steam recorded it but still ran the
-# title on the host. There's no environment option: this Steam ignores the devkit env file.
-#
-# devkit-utils is Valve's (LGPL, gitlab.steamos.cloud/devkit/steamos-devkit). FrameDrop and
-# the devkit client copy it to ~/devkit-utils; if that isn't there, it's fetched at a pinned
-# commit into ~/.cache/frametop-framedrop.
-set -euo pipefail
-
-devkit_rev=a00ceb7d91ea44a0c3e714a91a06417d6e5cdb33
-cache=$HOME/.cache/frametop-framedrop
-
-usage() { sed -n '7,10p' "$0" | sed 's/^# \{0,1\}//' >&2; exit 2; }
-
-utils() {
-  if [ -e "$HOME/devkit-utils/steam-client-create-shortcut" ]; then
-    echo "$HOME/devkit-utils"; return
-  fi
-  if [ ! -e "$cache/devkit-utils/steam-client-create-shortcut" ]; then
-    echo "fetching devkit-utils ($devkit_rev)" >&2
-    local tmp
-    tmp=$(mktemp -d)
-    git -C "$tmp" init -q
-    git -C "$tmp" fetch -q --depth 1 https://gitlab.steamos.cloud/devkit/steamos-devkit.git "$devkit_rev"
-    git -C "$tmp" checkout -q FETCH_HEAD
-    mkdir -p "$cache"
-    rm -rf "$cache/devkit-utils"
-    cp -r "$tmp/client/devkit-utils" "$cache/devkit-utils"
-    rm -rf "$tmp"
-  fi
-  echo "$cache/devkit-utils"
-}
-
-[ $# -ge 1 ] || usage
-cmd=$1; shift
-case $cmd in
-  add)
-    [ $# -ge 3 ] || usage
-    name=$1 src=$2 start=$3; shift 3
-    case $name in *-*) echo "NAME can't contain '-' (Steam refuses it)" >&2; exit 2 ;; esac
-    compat=
-    while [ $# -gt 0 ]; do
-      case $1 in
-        --compat) compat=${2:?}; shift ;;
-        *) usage ;;
-      esac
-      shift
-    done
-    u=$(utils)
-    dir=$(python3 "$u/steamos-prepare-upload" --gameid "$name" | python3 -c 'import json,sys; print(json.load(sys.stdin)["directory"])')
-    # FrameDrop rsyncs the unpacked zip; --delete as a clean upload would.
-    rsync -a --delete "$src/" "$dir/"
-    parms=$(python3 - "$name" "$dir" "$start" "$compat" <<'EOF'
-import json, sys
-name, directory, start, compat = sys.argv[1:]
-print(json.dumps({
-    "gameid": name, "directory": directory,
-    "argv": [start], "env": {},
-    "settings": {"steam_play": "0", "compat_tool": compat},
-    "force_appid": "", "lepton_args": "",
-}))
-EOF
-)
-    res=$(python3 "$u/steam-client-create-shortcut" --parms "$parms" | tail -1)
-    echo "Steam: $res"
-    case $res in *'"error"'*) exit 1 ;; esac
-    echo "registered $name ($dir)"
-    ;;
-  run)
-    [ $# -eq 1 ] || usage
-    python3 "$(utils)/steam-devkit-rpc" run-game "gameid=$1" | tail -1
-    echo
-    ;;
-  remove)
-    [ $# -eq 1 ] || usage
-    python3 "$(utils)/steamos-delete" --delete-title "$1"
-    rm -f "$HOME/devkit-game/$1"-*.json
-    ;;
-  list)
-    python3 "$(utils)/steam-devkit-rpc" list-shortcuts
-    ;;
-  *) usage ;;
-esac

framedrop/installer/frametop-install.sh

@@ -1,58 +0,0 @@
-#!/usr/bin/env bash
-# Frametop's FrameDrop installer: the start command of the "Frametop" title that FrameDrop
-# puts in the Steam library. Playing it installs Frametop (or updates it) with the one-line
-# installer, get.sh --yes, and shows its progress in a window.
-#
-# Steam ends a title's whole process tree when it's quit, and starts it with a high OOM score,
-# so the install runs in a user service of its own (frametop-framedrop-install) and the window
-# only follows its log. Quitting or closing the window leaves the install running; playing the
-# title again reattaches to it.
-#
-# Usage: frametop-install.sh [--dry-run]
-#   --dry-run  clone into ~/.cache/frametop-framedrop/dry-run instead of ~/frametop, and
-#              don't run install.sh (get.sh --clone-only), for testing this flow
-set -u
-
-here=$(cd "$(dirname "$0")" && pwd)
-self=$here/$(basename "$0")
-
-# A Linux title can be started in the Steam Linux Runtime container, which has no git, podman,
-# systemctl, or GTK. Start this again on the host. (SteamOS 0.3.0 runs devkit titles on the
-# host anyway; this is for when FrameDrop or Steam picks the runtime.)
-if [ -e /run/pressure-vessel ]; then
-  exec flatpak-spawn --host --watch-bus --env=DISPLAY="${DISPLAY-}" \
-    --env=XDG_RUNTIME_DIR="${XDG_RUNTIME_DIR-}" --env=SteamAppId="${SteamAppId-}" \
-    --env=ENABLE_GAMESCOPE_WSI="${ENABLE_GAMESCOPE_WSI-}" /usr/bin/bash "$self" "$@"
-fi
-
-# Steam adds its overlay and runtime libraries to every child; host tools don't want them.
-unset LD_PRELOAD LD_LIBRARY_PATH
-export PATH=/usr/local/bin:/usr/bin:/bin
-
-dry_run=0
-[ "${1-}" = --dry-run ] && dry_run=1
-
-unit=frametop-framedrop-install
-state=$HOME/.cache/frametop-framedrop
-log=$state/install.log
-mkdir -p "$state"
-
-get_args="--yes"
-[ "$dry_run" = 1 ] && get_args="--yes --clone-only --dir $state/dry-run"
-
-# Start the install unless one is running already. RemainAfterExit keeps its result for the
-# window; the next start clears it.
-if [ "$(systemctl --user show -P ActiveState "$unit" 2>/dev/null)" != activating ]; then
-  systemctl --user stop "$unit" 2>/dev/null
-  systemctl --user reset-failed "$unit" 2>/dev/null
-  : >"$log"
-  systemd-run --user --unit="$unit" --description="Frametop install (FrameDrop)" \
-    --property=Type=oneshot --property=RemainAfterExit=yes \
-    --property=StandardOutput="truncate:$log" --property=StandardError=inherit \
-    --setenv=HOME="$HOME" --setenv=PATH="$PATH" --setenv=TERM=dumb \
-    --working-directory="$HOME" --quiet --no-block \
-    /usr/bin/bash -c 'set -o pipefail; curl -fsSL https://deejanuz.github.io/frametop/get.sh | bash -s -- '"$get_args" ||
-    { echo "couldn't start the install service" >&2; exit 1; }
-fi
-
-exec /usr/bin/python3 "$here/progress.py" "$unit" "$log"

framedrop/installer/progress.py

@@ -1,125 +0,0 @@
-#!/usr/bin/env python3
-"""Progress window for the FrameDrop installer: follows the install service's log and state.
-
-Usage: progress.py UNIT LOG
-
-Closing the window doesn't stop the install; it keeps running in the user service UNIT.
-"""
-import re
-import subprocess
-import sys
-
-import gi
-
-gi.require_version("Gtk", "4.0")
-gi.require_version("Adw", "1")
-from gi.repository import Adw, GLib, Gtk, Pango  # noqa: E402
-
-UNIT, LOG = sys.argv[1], sys.argv[2]
-ANSI = re.compile(r"\x1b\[[0-9;]*[A-Za-z]")
-# install.sh marks each step with "== N/10 what it is"
-STEP = re.compile(r"^== (\d+)/(\d+) (.*)$")
-DONE_TEXT = ("Frametop is installed. Restart SteamVR once, or reboot the headset, so it loads "
-             "Frametop's driver. Then open Launch a program, then Desktop.")
-
-
-def unit_state():
-    out = subprocess.run(
-        ["systemctl", "--user", "show", "-P", "ActiveState", UNIT],
-        capture_output=True, text=True).stdout.strip()
-    return out or "inactive"
-
-
-class Window(Adw.ApplicationWindow):
-    def __init__(self, app):
-        super().__init__(application=app, title="Frametop")
-        self.set_default_size(900, 600)
-        self.offset = 0
-        self.partial = ""
-
-        self.status = Gtk.Label(label="Installing Frametop", xalign=0, wrap=True)
-        self.status.add_css_class("title-2")
-        self.detail = Gtk.Label(label="Starting...", xalign=0, wrap=True)
-        self.bar = Gtk.ProgressBar()
-        self.bar.pulse()
-
-        self.text = Gtk.TextView(editable=False, cursor_visible=False, monospace=True,
-                                 wrap_mode=Pango.WrapMode.WORD_CHAR)
-        self.text.set_left_margin(8)
-        self.text.set_right_margin(8)
-        scroll = Gtk.ScrolledWindow(vexpand=True, child=self.text)
-        self.scroll = scroll
-
-        self.note = note = Gtk.Label(
-            label="You can close this window: the install keeps going. Play Frametop again to "
-                  "come back to it.", xalign=0, wrap=True)
-        note.add_css_class("dim-label")
-        close = Gtk.Button(label="Close", halign=Gtk.Align.END)
-        close.connect("clicked", lambda *_: self.close())
-
-        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12,
-                      margin_top=18, margin_bottom=18, margin_start=18, margin_end=18)
-        for w in (self.status, self.detail, self.bar, scroll, note, close):
-            box.append(w)
-        view = Adw.ToolbarView(content=box)
-        view.add_top_bar(Adw.HeaderBar())
-        self.set_content(view)
-
-        self.finished = False
-        GLib.timeout_add(500, self.tick)
-        self.tick()
-
-    def add_lines(self, lines):
-        buf = self.text.get_buffer()
-        for line in lines:
-            m = STEP.match(line)
-            if m:
-                n, total, what = int(m[1]), int(m[2]), m[3]
-                self.bar.set_fraction((n - 1) / total)
-                self.detail.set_label(f"Step {n} of {total}: {what}")
-            buf.insert(buf.get_end_iter(), line + "\n")
-        # Keep the view at the newest line.
-        end = buf.create_mark(None, buf.get_end_iter(), False)
-        self.text.scroll_mark_onscreen(end)
-        buf.delete_mark(end)
-
-    def tick(self):
-        try:
-            with open(LOG, "rb") as f:
-                f.seek(self.offset)
-                data = f.read()
-                self.offset += len(data)
-        except FileNotFoundError:
-            data = b""
-        if data:
-            text = self.partial + ANSI.sub("", data.decode("utf-8", "replace")).replace("\r", "\n")
-            *lines, self.partial = text.split("\n")
-            self.add_lines(lines)
-
-        state = unit_state()
-        if state == "activating":
-            if self.bar.get_fraction() == 0:
-                self.bar.pulse()
-            return True
-        if self.partial:
-            self.add_lines([self.partial])
-            self.partial = ""
-        self.note.set_visible(False)
-        if state == "active":
-            self.status.set_label("Done")
-            self.detail.set_label(DONE_TEXT)
-            self.bar.set_fraction(1)
-        else:
-            self.status.set_label("The install stopped")
-            self.detail.set_label("The log above says why. Play Frametop again to try again.")
-        return False
-
-
-def main():
-    app = Adw.Application(application_id="io.github.deejanuz.FrametopInstall")
-    app.connect("activate", lambda a: Window(a).present())
-    app.run([])
-
-
-if __name__ == "__main__":
-    main()

framedrop/probe/probe.sh

@@ -1,114 +0,0 @@
-#!/usr/bin/env bash
-# FrameDrop proof of concept, step 1: run as a Steam "Devkit Game" (what FrameDrop installs a
-# Linux zip as) and record what an installer started from Steam could use: host or Steam Linux
-# Runtime container, podman, the user's systemd, git, the network, GTK, and a window on screen.
-# Register and start it: framedrop/devkit.sh add FrametopProbe framedrop/probe "./probe.sh native"
-#                       framedrop/devkit.sh run FrametopProbe
-# Usage: probe.sh LABEL
-# Writes ~/.cache/frametop-framedrop/probe-LABEL.log, replacing the previous one.
-label=${1:-unlabeled}
-out=$HOME/.cache/frametop-framedrop
-mkdir -p "$out"
-log=$out/probe-$label.log
-exec >"$log" 2>&1
-
-here=$(cd "$(dirname "$0")" && pwd)
-section() { printf '\n== %s\n' "$1"; }
-have() { command -v "$1" >/dev/null 2>&1; }
-check() { # check NAME CMD...: one line, ok or failed with the exit status
-  local name=$1; shift
-  if out_=$(timeout 20 "$@" 2>&1); then echo "ok      $name: $(echo "$out_" | head -1)"
-  else echo "FAILED  $name (exit $?): $(echo "$out_" | head -2 | tr '\n' ' ')"; fi
-}
-
-section "when, who, where"
-date -Is
-echo "label=$label uid=$(id -u) user=$(id -un) pwd=$PWD here=$here"
-echo "args: $*"
-grep -E '^(ID|VARIANT_ID|VERSION_ID|BUILD_ID|PRETTY_NAME)=' /etc/os-release
-
-section "container?"
-for p in /run/pressure-vessel /.flatpak-info /run/host/os-release; do
-  [ -e "$p" ] && echo "present: $p" || echo "absent:  $p"
-done
-echo "container=${container-} PRESSURE_VESSEL_RUNTIME=${PRESSURE_VESSEL_RUNTIME-}"
-[ -e /run/host/os-release ] && grep -E '^(ID|VARIANT_ID)=' /run/host/os-release
-
-section "environment"
-env | grep -E '^(PATH|HOME|XDG_[A-Z_]+|DISPLAY|WAYLAND_DISPLAY|DBUS_SESSION_BUS_ADDRESS|SteamAppId|SteamGameId|STEAM_COMPAT_[A-Z_]+|LD_LIBRARY_PATH|LD_PRELOAD|SDL_[A-Z_]+|GDK_BACKEND|ENABLE_[A-Z_]+|PRESSURE_VESSEL_[A-Z_]+)=' | sort
-echo "process tree:"
-pid=$$
-for _ in 1 2 3 4 5 6 7 8; do
-  [ "$pid" -le 1 ] 2>/dev/null && break
-  printf '  %s %s\n' "$pid" "$(tr '\0' ' ' </proc/"$pid"/cmdline 2>/dev/null | cut -c1-200)"
-  pid=$(awk '/^PPid:/{print $2}' /proc/"$pid"/status 2>/dev/null)
-done
-
-# Steam adds its overlay (LD_PRELOAD) and runtime libraries to every child. An installer has
-# to drop them before running host tools, as the checks below do.
-unset LD_PRELOAD
-LD_LIBRARY_PATH=$(printf %s "${LD_LIBRARY_PATH-}" | tr ':' '\n' | grep -v -e '/Steam/' -e '^$' -e 'x86_64' -e 'i386' | paste -sd:)
-[ -n "$LD_LIBRARY_PATH" ] && export LD_LIBRARY_PATH || unset LD_LIBRARY_PATH
-PATH=$(printf %s "$PATH" | tr ':' '\n' | grep -v '/Steam/' | paste -sd:)
-echo "cleaned: PATH=$PATH LD_LIBRARY_PATH=${LD_LIBRARY_PATH-}"
-
-section "tools"
-for t in bash git curl python3 podman distrobox systemctl systemd-run busctl gdbus flatpak-spawn \
-         steam-runtime-launch-client konsole zenity kdialog; do
-  printf '%-28s %s\n' "$t" "$(command -v "$t" || echo -)"
-done
-
-section "what an installer needs"
-check "home writable" sh -c 'f=$HOME/.cache/frametop-framedrop/.w && : >"$f" && rm "$f" && echo yes'
-check "~/frametop visible" sh -c 'ls -d "$HOME/frametop" && git -C "$HOME/frametop" log -1 --format=%h'
-have git && check "git ls-remote github" git ls-remote --heads https://github.com/DeeJanuz/frametop.git experimental
-have curl && check "curl get.sh" sh -c 'curl -fsSL https://deejanuz.github.io/frametop/get.sh | head -1'
-have podman && check "podman ps" podman ps --format '{{.Names}}'
-have distrobox && check "distrobox list" distrobox list
-have systemctl && check "systemctl --user" systemctl --user is-system-running
-have systemctl && check "user units visible" systemctl --user is-enabled frametop-input-relay.service
-have python3 && check "python3 gi Gtk 4" python3 -c 'import gi; gi.require_version("Gtk","4.0"); gi.require_version("Adw","1"); from gi.repository import Gtk, Adw; print(Gtk.get_major_version(), Gtk.get_minor_version())'
-
-section "escape to the host (needed if this is a container)"
-# A transient user unit runs in the host's user manager, outside any container.
-if have systemd-run; then
-  rm -f "$out/escape-$label"
-  check "systemd-run --user" systemd-run --user --wait --collect --quiet -- \
-    sh -c "grep -E '^(ID|VARIANT_ID)=' /etc/os-release > '$out/escape-$label'; command -v podman git >> '$out/escape-$label'"
-  [ -s "$out/escape-$label" ] && sed 's/^/  host says: /' "$out/escape-$label"
-fi
-if have busctl; then
-  check "busctl --user (systemd1)" busctl --user get-property org.freedesktop.systemd1 /org/freedesktop/systemd1 org.freedesktop.systemd1.Manager Version
-fi
-
-section "window"
-# A plain GTK 4 window for 20 s. Watch for it on the Frame; "window: mapped" means GTK showed it.
-if have python3; then
-  timeout 40 python3 - <<'EOF'
-import sys
-try:
-    import gi
-    gi.require_version("Gtk", "4.0")
-    from gi.repository import Gtk, GLib
-except Exception as e:
-    print("window: no GTK 4:", e); sys.exit(0)
-app = Gtk.Application(application_id="io.github.deejanuz.FrametopProbe")
-def on_activate(app):
-    w = Gtk.ApplicationWindow(application=app, title="Frametop installer probe")
-    w.set_default_size(640, 240)
-    w.set_child(Gtk.Label(label="Frametop installer probe\n\nIf you can read this, a FrameDrop install can show progress.\nThis window closes in 20 seconds."))
-    w.connect("map", lambda *_: print("window: mapped", flush=True))
-    w.present()
-    GLib.timeout_add_seconds(20, app.quit)
-app.connect("activate", on_activate)
-print("window: display", Gtk.Widget.get_display(Gtk.Label()) if hasattr(Gtk.Widget, "get_display") else "?", flush=True)
-app.run([])
-print("window: closed")
-EOF
-  echo "window exit: $?"
-else
-  echo "window: no python3"
-fi
-
-section "done"
-date -Is

scripts/update-check.py

@@ -49,6 +49,8 @@ PACKAGES = {
             "after a desktop restart; floating a window; no blur behind the taskbar's menus",
     "plasma-workspace": "the taskbar and panels after a desktop restart; no DiscoverNotifier or "
                         "ibus-daemon inside the desktop",
+    "at-spi2-core": "an AT-SPI-aware app appears on the nested desktop's accessibility bus; "
+                    "the registry stops and comes back after a desktop restart",
     "gamescope": "the headset's volume buttons with nothing focused; typing goes where you last clicked",
     "bluez": "a Bluetooth mouse reconnecting after it sleeps",
 }
@@ -162,6 +164,14 @@ def check_host():
         ("/usr/bin/kwin_wayland_wrapper", "FAIL", "the desktop can't start KWin"),
         ("/usr/bin/startplasma-wayland", "FAIL", "the desktop can't start Plasma"),
         ("/usr/bin/dbus-run-session", "FAIL", "the desktop can't start its session bus"),
+        ("/usr/bin/python3", "warn", "nested accessibility can't run its startup helper"),
+        ("/usr/bin/gdbus", "warn", "nested accessibility can't discover or check its bus"),
+        ("/usr/lib/at-spi-bus-launcher", "warn", "nested accessibility can't start its bus"),
+        ("/usr/lib/at-spi2-registryd", "warn", "nested accessibility has no fallback registry"),
+        ("/usr/share/dbus-1/services/org.a11y.Bus.service", "warn",
+         "nested accessibility can't activate its bus"),
+        ("/usr/share/dbus-1/accessibility-services/org.a11y.atspi.Registry.service", "warn",
+         "nested accessibility can't activate its registry natively"),
         (f"{STEAMVR_BIN}/vrcmd", "FAIL", "the 3D mouse can't find panels"),
         (f"{STEAMVR_BIN}/vrpathreg", "warn", "the pointer driver can't be installed or removed"),
         ("/usr/share/deckard/mesavars.sh", "warn", "the desktop starts without SteamOS's Mesa settings"),

session/frametop-session.sh

@@ -29,7 +29,7 @@ for var in $(compgen -e); do
   case $var in
     LD_LIBRARY_PATH | LD_PRELOAD | STEAM_* | Steam* | SRT_* | PRESSURE_VESSEL_* | MANGOHUD_* | \
       ENABLE_VK_LAYER_VALVE_steam_overlay_* | STEAMVIDEOTOKEN | QT_IM_MODULE | GTK_IM_MODULE | \
-      XMODIFIERS) unset "$var" ;;
+      XMODIFIERS | AT_SPI_BUS_ADDRESS) unset "$var" ;;
   esac
 done
 
@@ -190,6 +190,21 @@ if [ "$remote" = 1 ]; then
   "$here/remote-ctl.sh" start
 fi
 
+# AT-SPI: start the registry inside Plasma's autostart, after KWin has published the
+# nested displays. Starting it before startplasma could bind to the host's X display.
+# This config belongs only to Frametop; the host desktop's autostart is unchanged.
+autostart=$XDG_CONFIG_HOME/autostart/frametop-atspi.desktop
+mkdir -p "$(dirname "$autostart")"
+cat > "$autostart" <<EOF
+[Desktop Entry]
+Type=Application
+Name=Frametop accessibility
+Exec="$here/ft-atspi"
+X-KDE-autostart-phase=2
+OnlyShowIn=KDE;
+NoDisplay=true
+EOF
+
 # ft-floatd (floating windows) runs inside the Plasma session, on its D-Bus: started from
 # the session's autostart, which only this desktop reads (XDG_CONFIG_HOME above).
 autostart=$XDG_CONFIG_HOME/autostart/frametop-floatd.desktop

session/ft-atspi

@@ -0,0 +1,87 @@
+#!/usr/bin/python3
+"""Start AT-SPI on this nested desktop's live bus, after KWin has set its displays."""
+import ast
+import os
+import signal
+import subprocess
+import sys
+import time
+
+DBUS = "org.freedesktop.DBus"
+DBUS_PATH = "/org/freedesktop/DBus"
+REGISTRY = "org.a11y.atspi.Registry"
+
+
+def call(address, destination, path, method, *args):
+    return subprocess.run(
+        ["gdbus", "call", "--address", address, "--dest", destination,
+         "--object-path", path, "--method", method, "--timeout", "5", *args],
+        check=True, capture_output=True, text=True, timeout=6).stdout.strip()
+
+
+def stop(child):
+    if child.poll() is None:
+        child.terminate()
+    try:
+        child.wait(timeout=3)
+    except subprocess.TimeoutExpired:
+        child.kill()
+        child.wait()
+
+
+def run_registry(address, session):
+    # SteamOS's registryd stays alive after a bus disconnect. Keep only our own
+    # child tied to both private buses; no host PID lookup or broad process kill.
+    registry = subprocess.Popen(["/usr/lib/at-spi2-registryd"])
+    try:
+        while registry.poll() is None:
+            try:
+                call(session, DBUS, DBUS_PATH, DBUS + ".GetId")
+                call(address, DBUS, DBUS_PATH, DBUS + ".GetId")
+            except subprocess.SubprocessError:
+                break  # Normal session shutdown or loss of its accessibility bus.
+            # Each check starts two gdbus processes, and SteamVR needs the CPU.
+            time.sleep(5)
+    finally:
+        stop(registry)
+
+
+def start():
+    session = os.environ.get("DBUS_SESSION_BUS_ADDRESS")
+    runtime = os.environ.get("XDG_RUNTIME_DIR", "")
+    if not session or os.path.basename(runtime) != "frametop":
+        return  # Do not autolaunch a bus or touch the host desktop.
+    os.environ.pop("AT_SPI_BUS_ADDRESS", None)
+    reply = call(session, "org.a11y.Bus", "/org/a11y/bus", "org.a11y.Bus.GetAddress")
+    address, = ast.literal_eval(reply)
+    if not isinstance(address, str) or not address.startswith("unix:"):
+        raise ValueError("org.a11y.Bus returned no local accessibility bus")
+    if call(address, DBUS, DBUS_PATH, DBUS + ".NameHasOwner", REGISTRY) == "(true,)":
+        return
+    # Activation otherwise inherits the accessibility daemon's old environment (and
+    # DBUS_SESSION_BUS_ADDRESS is the accessibility bus itself). Pin the live bus.
+    env = {key: os.environ.get(key, "") for key in (
+        "DISPLAY", "WAYLAND_DISPLAY", "XAUTHORITY", "XDG_RUNTIME_DIR",
+        "XDG_CONFIG_HOME", "DBUS_SESSION_BUS_ADDRESS")}
+    env["AT_SPI_BUS_ADDRESS"] = address
+    call(address, DBUS, DBUS_PATH, DBUS + ".UpdateActivationEnvironment", repr(env))
+    try:
+        call(address, DBUS, DBUS_PATH, DBUS + ".StartServiceByName", REGISTRY, "0")
+    except subprocess.CalledProcessError:
+        # SteamOS's launcher can select dbus-broker because we are in a user unit,
+        # but the private session bus has no systemd activation manager. Reuse its
+        # bus rather than starting another launcher/bus. Never replace an owner.
+        if call(address, DBUS, DBUS_PATH, DBUS + ".NameHasOwner", REGISTRY) == "(true,)":
+            return
+        os.environ["AT_SPI_BUS_ADDRESS"] = address
+        # registryd itself refuses to queue behind an existing registry, including
+        # races with native activation. The watcher cleans up only our own child.
+        run_registry(address, session)
+
+
+if __name__ == "__main__":
+    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit(0))
+    try:
+        start()
+    except (OSError, ValueError, SyntaxError, subprocess.SubprocessError) as error:
+        print(f"frametop: accessibility unavailable: {error}", file=sys.stderr)

session/keep-apps.sh

@@ -10,7 +10,7 @@ cg=$(systemctl --user show -p ControlGroup --value "$unit" 2>/dev/null)
 
 # The desktop's own processes stay in the unit and stop with it: the session, KWin,
 # Plasma, and the session services it started (portals, input methods, kded, wallet...).
-own='^(frametop-sessi|dbus-|startplasma|plasma|kwin|Xwayland|ksmserver|krdpserver|Xvnc|xfreerdp|ft-layout|'
+own='^(frametop-sessi|dbus-|startplasma|plasma|kwin|Xwayland|ksmserver|krdpserver|Xvnc|xfreerdp|ft-layout|ft-atspi|'
 own+='kded|kactivitymanage|kaccess|kglobalaccel|kscreen|kwalletd|ksecretd|polkit-kde|org_kde_|baloo|'
 own+='xembedsniproxy|gmenudbusmenu|DiscoverNotifie|kimpanel|ibus|xdg-|at-spi|dconf-service|fusermount|agent)'
 keep=()