Arch packages: release r30

README: universal install, controller pairing; install.sh WebKitGTK hint
Add Rift S controller pairing to Settings
2026-10-17 18:02:35 +02:00 · 2026-10-17 14:47:43 +03:00 · 2026-10-17 14:30:54 +03:00 · 2026-10-17 14:25:21 +03:00 · 2026-10-17 14:25:21 +03:00 · 2026-10-16 22:22:55 +03:00
43 changed files with 2360 additions and 66 deletions
@@ -136,6 +136,10 @@ if(NOT WIN32)
 	find_package(Systemd MODULE)
 	find_package(OpenGLES MODULE COMPONENTS V3)
 	find_library(RT_LIBRARY rt)
+	# glibc before 2.34 (the Steam Runtime SDK) keeps shm_open in librt.
+	if(RT_LIBRARY)
+		link_libraries(${RT_LIBRARY})
+	endif()
 endif()
 if(NOT ANDROID AND NOT MSVC)
 	find_package(PkgConfig MODULE)
@@ -15,7 +15,7 @@ Free and open source, built on Monado and Basalt. Steam and SteamVR are installe
 - In-headset Room Setup with floor calibration, a persistent boundary and saved-room recognition.
 - A stable dashboard and a held position with IMU rotation when headset tracking is lost.
 - Headset and both Touch controller tracking, with controller haptics.
- Rift S Settings for device state, software IPD, recentering and Room Setup, with an 80 fps zero-copy headset preview and fullscreen. The preview drops to 1 fps in standby.
+- Rift S Settings for device state, controller pairing, software IPD, recentering and Room Setup, with an 80 fps zero-copy headset preview and fullscreen. The preview drops to 1 fps in standby.
 - An in-headset Desktop overlay with mouse, scrolling and keyboard input on KDE Plasma Wayland.

 ## Requirements
@@ -24,12 +24,33 @@ Free and open source, built on Monado and Basalt. Steam and SteamVR are installe
 - An x86-64 Linux desktop with a systemd user session and local USB seat access.
 - Native Steam with SteamVR installed from the Steam library.
 - A Vulkan-capable GPU and drivers supported by SteamVR's direct display mode. Current testing uses an NVIDIA RTX 3090.
- The patched Basalt build below. An unpatched Basalt lacks the required reconnect support.
+- The patched Basalt build. The Arch packages include it; an unpatched Basalt lacks the required reconnect support.
 - KDE Plasma Wayland for the Desktop overlay.

-## Install from source
+## Install

-AUR packages are planned and have not been published. Build from source for now. Close SteamVR and Settings before installing or upgrading.
+Close SteamVR and Settings before installing or upgrading.
+
+On Arch Linux and derivatives, install the prebuilt package from the [latest release](https://github.com/lbgos/rift-s-linux/releases/latest):
+
+```sh
+curl -LO https://github.com/lbgos/rift-s-linux/releases/download/r30/rift-s-linux-bin-30-1-x86_64.pkg.tar.zst
+sudo pacman -U rift-s-linux-bin-30-1-x86_64.pkg.tar.zst
+```
+
+To build the latest `main` instead, run `makepkg -si` in [packaging/aur/basalt-monado-rifts](packaging/aur/basalt-monado-rifts), then in [packaging/aur/rift-s-linux-git](packaging/aur/rift-s-linux-git). AUR submission is pending.
+
+On other distributions, install the universal build into your home directory. It needs no SteamVR launch option; the udev rule asks for your password once. Settings needs glibc 2.35 or newer and WebKitGTK 4.1 (Debian/Ubuntu `libwebkit2gtk-4.1-0`, Fedora `webkit2gtk4.1`).
+
+```sh
+curl -LO https://github.com/lbgos/rift-s-linux/releases/download/r30/rift-s-linux-r30-x86_64.tar.xz
+tar -xf rift-s-linux-r30-x86_64.tar.xz
+./rift-s-linux-r30-x86_64/install.sh
+```
+
+`install.sh --uninstall` removes it. Remove the universal build before installing a system package, and the reverse. [packaging/universal](packaging/universal) describes how it is built.
+
+## Build from source

 Install a C/C++ toolchain, CMake, Ninja, Eigen, TBB, fmt, OpenCV, Vulkan headers and loader, glslang, libusb, SDL2, cJSON, libcap, systemd and the X11, Wayland and DRM development libraries. The Desktop overlay also needs PipeWire development files, wayland-scanner, wayland-protocols and plasma-wayland-protocols. Settings needs Rust/Cargo, Node.js, pnpm, GTK3, WebKitGTK 4.1, shaderc's `glslc` and desktop-file-utils.

@@ -80,7 +101,7 @@ EOF
 sudo udevadm control --reload-rules
 ```

-The install registers the SteamVR driver automatically through a systemd user service, including when SteamVR is installed later or in another library. It also installs the Room Setup layer, session guard and Desktop overlay. Check that CMake enables `rifts-desktop`; it skips the overlay if its dependencies are missing. SteamVR loads the driver in-process, so no separate `monado-service` needs to run.
+The install registers the SteamVR driver automatically through a systemd user service, including when SteamVR is installed later or in another library. The same service sets SteamVR's launch option to `vrmonitor.sh %command%`, because Steam otherwise starts SteamVR in the Steam Linux Runtime container, where the driver is not visible. If SteamVR already has custom launch options, they are left alone and the service logs the command to add. It also installs the Room Setup layer, session guard and Desktop overlay. Check that CMake enables `rifts-desktop`; it skips the overlay if its dependencies are missing. SteamVR loads the driver in-process, so no separate `monado-service` needs to run.

 Build and install Settings:

@@ -94,12 +115,14 @@ pnpm tauri build --no-bundle -- --locked
 ## First run

 1. Connect USB and DisplayPort. Reconnect the headset after installation to apply USB access rules.
-2. Open Steam and click SteamVR in the library.
+2. Open Steam and click SteamVR in the library. If Steam was running during the install, restart Steam once first.
 3. Put on the headset and complete Room Setup. Set the floor and draw the boundary for your physical play area.
 4. On later starts, look around the saved room to recognize it. Check the floor and boundary before playing.
 5. Open Rift S Settings from the desktop launcher. For the full-resolution preview, enable its next-start preference and relaunch SteamVR once. On KDE, the native VR View opens minimized to supply the preview.
 6. Open the dashboard's Desktop tab to use the KDE desktop inside the headset.

+To pair a new or replacement Touch controller, close SteamVR and use Pair controller in Settings. Hold Menu + Y (left) or Oculus + B (right) until the controller light flashes, then select it.
+
 ## Known issues

 - USB or DisplayPort loss can crash SteamVR's compositor. Reconnect the headset and relaunch SteamVR manually. Recovery does not launch SteamVR automatically.
@@ -53,6 +53,8 @@ foreach(_xml ${_protocols})
 endforeach()

 set(RIFTS_DESKTOP_MANIFEST "${CMAKE_INSTALL_FULL_DATADIR}/rifts-desktop/rifts-desktop.vrmanifest")
+# Relocated installs find the manifest relative to the binary.
+file(RELATIVE_PATH RIFTS_DESKTOP_MANIFEST_FROM_BIN "${CMAKE_INSTALL_FULL_BINDIR}" "${RIFTS_DESKTOP_MANIFEST}")
 add_executable(rifts-desktop
 	src/capture.cpp
 	src/gpu.cpp
@@ -65,7 +67,8 @@ set_target_properties(rifts-desktop PROPERTIES CXX_STANDARD 20 CXX_STANDARD_REQU
 target_include_directories(rifts-desktop PRIVATE
 	"${CMAKE_CURRENT_BINARY_DIR}"
 	"${CMAKE_CURRENT_SOURCE_DIR}/../src/external/openvr_includes")
-target_compile_definitions(rifts-desktop PRIVATE RIFTS_DESKTOP_MANIFEST="${RIFTS_DESKTOP_MANIFEST}")
+target_compile_definitions(rifts-desktop PRIVATE RIFTS_DESKTOP_MANIFEST="${RIFTS_DESKTOP_MANIFEST}"
+                                                  RIFTS_DESKTOP_MANIFEST_FROM_BIN="${RIFTS_DESKTOP_MANIFEST_FROM_BIN}")
 target_link_libraries(rifts-desktop PRIVATE PkgConfig::RIFTS_DESKTOP_DEPS Vulkan::Vulkan ${CMAKE_DL_LIBS})

 configure_file(rifts-desktop.desktop.in rifts-desktop.desktop @ONLY)
@@ -289,7 +289,7 @@ private:
 		auto *self = static_cast<KWinDesktop *>(data);
 		if (strcmp(interface, wl_output_interface.name) == 0 && version >= 4) {
 			auto o = std::make_unique<Output>(Output{self, id});
-			o->output = static_cast<wl_output *>(wl_registry_bind(registry, id, &wl_output_interface, 4));
+			o->output = static_cast<wl_output *>(wl_registry_bind(registry, id, &wl_output_interface, kOutputVersion));
 			wl_output_add_listener(o->output, &kOutput, o.get());
 			self->add_xdg(o.get());
 			self->outputs_.push_back(std::move(o));
@@ -425,14 +425,26 @@ private:
 	    .mode = [](void *, wl_output *, uint32_t, int32_t, int32_t, int32_t) {},
 	    .done = output_done,
 	    .scale = [](void *, wl_output *, int32_t) {},
+#ifdef WL_OUTPUT_NAME_SINCE_VERSION
 	    .name = output_name,
 	    .description = [](void *, wl_output *, const char *) {},
+#endif
 	};
+	// Older libwayland headers (the Steam Runtime SDK) stop at version 3; xdg-output
+	// then supplies the same connector name.
+#ifdef WL_OUTPUT_NAME_SINCE_VERSION
+	static constexpr uint32_t kOutputVersion = 4;
+#else
+	static constexpr uint32_t kOutputVersion = 3;
+#endif
 	static constexpr zxdg_output_v1_listener kXdgOutput = {
 	    .logical_position = xdg_position,
 	    .logical_size = xdg_size,
 	    .done = [](void *, zxdg_output_v1 *) {},
-	    .name = [](void *, zxdg_output_v1 *, const char *) {},
+	    .name = [](void *data, zxdg_output_v1 *, const char *name) {
+		    auto *o = static_cast<Output *>(data);
+		    if (o->name.empty()) o->name = name;
+	    },
 	    .description = [](void *, zxdg_output_v1 *, const char *) {},
 	};
 	static constexpr kde_output_order_v1_listener kOrder = {order_output, order_done};
@@ -27,6 +27,7 @@
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
+#include <filesystem>
 #include <iostream>
 #include <memory>
 #include <string>
@@ -36,6 +37,9 @@
 #ifndef RIFTS_DESKTOP_MANIFEST
 #define RIFTS_DESKTOP_MANIFEST "/usr/share/rifts-desktop/rifts-desktop.vrmanifest"
 #endif
+#ifndef RIFTS_DESKTOP_MANIFEST_FROM_BIN
+#define RIFTS_DESKTOP_MANIFEST_FROM_BIN "../share/rifts-desktop/rifts-desktop.vrmanifest"
+#endif

 namespace rd {
 namespace {
@@ -193,11 +197,25 @@ write_ppm(const std::string &path, const std::vector<uint8_t> &bgra, uint32_t w,
 	return fclose(f) == 0;
 }

+// The installed manifest, next to this binary when the install was moved to another prefix.
+const std::string &
+manifest_path()
+{
+	static const std::string path = [] {
+		std::error_code error;
+		auto exe = std::filesystem::read_symlink("/proc/self/exe", error);
+		auto local = (exe.parent_path() / RIFTS_DESKTOP_MANIFEST_FROM_BIN).lexically_normal();
+		return !error && std::filesystem::is_regular_file(local, error) ? local.string()
+		                                                                 : std::string(RIFTS_DESKTOP_MANIFEST);
+	}();
+	return path;
+}
+
 bool
 ensure_registered(const Vr &vr)
 {
 	bool installed = vr.apps->IsApplicationInstalled(kAppKey);
-	auto result = vr.apps->AddApplicationManifest(RIFTS_DESKTOP_MANIFEST, false);
+	auto result = vr.apps->AddApplicationManifest(manifest_path().c_str(), false);
 	if (result != vr::VRApplicationError_None) {
 		fprintf(stderr, "rifts-desktop: manifest registration: %s\n", vr.apps->GetApplicationsErrorNameFromEnum(result));
 		return false;
@@ -223,7 +241,7 @@ run_registration(bool remove)
 	// Not LaunchDashboardOverlay: SteamVR identifies this process as the app by its path,
 	// so the overlay would count as running. Callers start it themselves.
 	if (remove) {
-		vr.apps->RemoveApplicationManifest(RIFTS_DESKTOP_MANIFEST);
+		vr.apps->RemoveApplicationManifest(manifest_path().c_str());
 	} else {
 		if (!ensure_registered(vr)) { vr_disconnect(); return 1; }
 	}
@@ -0,0 +1,49 @@
+pkgbase = basalt-monado-rifts
+	pkgdesc = Basalt tracking library with Rift S lifecycle and worker defaults
+	pkgver = 0.1.r544.gdf6e970
+	pkgrel = 1
+	url = https://gitlab.freedesktop.org/mateosss/basalt
+	arch = x86_64
+	license = BSD-2-Clause
+	license = BSD-3-Clause
+	license = MIT
+	license = BSL-1.0
+	makedepends = cmake
+	makedepends = ninja
+	makedepends = git
+	makedepends = eigen
+	makedepends = boost
+	depends = glibc
+	depends = libgcc
+	depends = libstdc++
+	depends = opencv
+	depends = onetbb
+	depends = fmt
+	provides = basalt-monado
+	provides = basalt-monado-git
+	conflicts = basalt-monado
+	conflicts = basalt-monado-git
+	options = !debug
+	options = !lto
+	source = basalt::git+https://gitlab.freedesktop.org/mateosss/basalt.git#commit=df6e970c8da7636eb401a09e3317fbeaaf829b9a
+	source = CLI11::git+https://github.com/CLIUtils/CLI11.git#commit=37bb6edc5317e99af72ef48405e65d9ca5218861
+	source = basalt-headers::git+https://gitlab.freedesktop.org/mateosss/basalt-headers.git#commit=e6db0fb84c69614bc4923fde6c52154c221c1768
+	source = opengv::git+https://github.com/laurentkneip/opengv.git#commit=91f4b19c73450833a40e463ad3648aae80b3a7f3
+	source = magic_enum::git+https://github.com/Neargye/magic_enum.git#commit=e046b69a3736d314fad813e159b1c192eaef92cd
+	source = Sophus::git+https://github.com/strasdat/Sophus.git#commit=d0b7315a0d90fc6143defa54596a3a95d9fa10ec
+	source = cereal::git+https://github.com/USCiLab/cereal.git#commit=ebef1e929807629befafbb2918ea1a08c7194554
+	source = 0001-keep-imu-frequency-per-tracker.patch
+	source = 0002-limit-workers-with-driver-calibration.patch
+	source = 0003-safe-recreation-and-realtime-worker-budget.patch
+	sha256sums = SKIP
+	sha256sums = SKIP
+	sha256sums = SKIP
+	sha256sums = SKIP
+	sha256sums = SKIP
+	sha256sums = SKIP
+	sha256sums = SKIP
+	sha256sums = a0bc2a766ad6ae5fdfa33cd80d45d12798d43efa4c34605ee6cf20bae157d18d
+	sha256sums = 607d53dadbd8ca5b0978d10378e631539bc8047ca0fce317b90d68a52f785a52
+	sha256sums = a434e76c66c129aa3a900ed151dd2dd9bc98b671451dda26855a438cff08b2ac
+
+pkgname = basalt-monado-rifts
@@ -0,0 +1,27 @@
+--- a/src/vit/vit_tracker.cpp
+++ b/src/vit/vit_tracker.cpp
+@@ -127,6 +127,7 @@
+     vector<bool> cam;
+   } calib_data_ready;
+   uint32_t cam_count;
+  double imu_calibration_frequency = -1;
+
+   Calibration<double> calib;
+   VioConfig vio_config;
+@@ -311,13 +312,13 @@
+     int i = imu_calib.imu_index;
+     ASSERT(i == 0, "More than one IMU unsupported (%d)", i);
+
+-    static double frequency = -1;
+    double &frequency = imu_calibration_frequency;
+     if (frequency == -1) {
+       frequency = imu_calib.frequency;
+       calib.imu_update_rate = frequency;
+     } else {
+-      ASSERT(frequency == calib.imu_update_rate, "Unsupported mix of IMU frequencies %lf != %lf", frequency,
+-             calib.imu_update_rate);
+      ASSERT(frequency == imu_calib.frequency, "Unsupported mix of IMU frequencies %lf != %lf", frequency,
+             imu_calib.frequency);
+     }
+
+     // Accelerometer calibration
@@ -0,0 +1,12 @@
+--- a/src/vit/vit_tracker.cpp
+++ b/src/vit/vit_tracker.cpp
+@@ -170,6 +170,9 @@
+     calib_data_ready.cam.resize(cam_count, false);
+ 
+     if (config->file == nullptr) {
+      // Driver-provided calibration still uses the default one-thread CPU budget.
+      tbb_global_control =
+          std::make_unique<tbb::global_control>(tbb::global_control::max_allowed_parallelism, num_threads);
+       // For the pipeline to work now, the user will need to use add_cam/imu_calibration
+       return;
+     }
@@ -0,0 +1,193 @@
+--- a/src/vit/vit_tracker.cpp
+++ b/src/vit/vit_tracker.cpp
+@@ -55,6 +55,7 @@
+ #include <sophus/se3.hpp>
+
+ #include <cstdio>
+#include <cstdlib>
+ #include <memory>
+ #include <string>
+ #include <thread>
+@@ -119,7 +120,7 @@
+   bool print_queue = false;
+   bool use_double = false;
+   bool deterministic = false;
+-  int num_threads = 1;
+  int num_threads = 4;
+
+   // VIO members
+   struct {
+@@ -170,7 +171,14 @@
+     calib_data_ready.cam.resize(cam_count, false);
+
+     if (config->file == nullptr) {
+-      // Driver-provided calibration still uses the default one-thread CPU budget.
+      // Bound the pool even without a unified config. A single thread can leave
+      // both five-camera pipeline stages behind; benchmarks may select 1..4 for comparison.
+      if (const char *value = std::getenv("BASALT_MAX_THREADS")) {
+        char *end = nullptr;
+        const long requested = std::strtol(value, &end, 10);
+        if (end != value && *end == '\0' && requested >= 1 && requested <= 4) num_threads = int(requested);
+      }
+      cout << "Basalt max parallelism=" << num_threads << "\n";
+       tbb_global_control =
+           std::make_unique<tbb::global_control>(tbb::global_control::max_allowed_parallelism, num_threads);
+       // For the pipeline to work now, the user will need to use add_cam/imu_calibration
+@@ -421,16 +429,37 @@
+
+   void stop() {
+     running = false;
+    // Discard queued images. The in-flight image finishes before the sentinel.
+    OpticalFlowInput::Ptr image;
+    while (image_data_queue->try_pop(image)) {}
+     image_data_queue->push(nullptr);
+    ImuData<double>::Ptr imu;
+    while (imu_data_queue->try_pop(imu)) {}
+    while (opt_flow_ptr->input_imu_queue.try_pop(imu)) {}
+     imu_data_queue->push(nullptr);
+     opt_flow_ptr->input_imu_queue.push(nullptr);
+
+    // VIO can exit on its IMU sentinel before flow finishes. Once it has exited,
+    // drain its bounded vision queue so the remaining producer cannot block.
+    std::atomic<bool> flow_joined{false};
+    thread drain_vision([&] {
+      while (!flow_joined.load()) {
+        if (vio->finished.load()) {
+          OpticalFlowResult::Ptr result;
+          while (vio->vision_data_queue.try_pop(result)) {}
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+      }
+    });
+    // Join while dynamic types and all connected queues still exist.
+    opt_flow_ptr->maybe_join();
+    flow_joined = true;
+    drain_vision.join();
+    vio->maybe_join();
+
+     if (print_queue) queues_printer_thread.join();
+     if (!deterministic) state_consumer_thread.join();
+     if (show_gui) ui.stop();
+-
+-    // TODO: There is a segfault when closing monado without starting the stream
+-    // happens in a lambda from keypoint_vio.cpp and ends at line c1alib_bias.hpp:112
+   }
+
+   void finalize() const {
+@@ -439,6 +468,16 @@
+   }
+
+   void reset() { vio->scheduleResetState(); }
+
+  // VIT submissions must not block restart when another input stream stalls.
+  // Keep bounded queues current by discarding their oldest pending sample.
+  template <typename T>
+  static void push_latest(tbb::concurrent_bounded_queue<T> &queue, const T &sample) {
+    while (!queue.try_push(sample)) {
+      T discarded;
+      queue.try_pop(discarded);
+    }
+  }
+
+   void push_imu_sample(const vit::ImuSample *s) {
+     // concurrent_bounded_queue expects Erasable and Allocator named
+@@ -448,8 +487,8 @@
+     data->t_ns = s->timestamp;
+     data->accel = {s->ax, s->ay, s->az};
+     data->gyro = {s->wx, s->wy, s->wz};
+-    imu_data_queue->push(data);
+-    opt_flow_ptr->input_imu_queue.push(data);
+    push_latest(*imu_data_queue, data);
+    push_latest(opt_flow_ptr->input_imu_queue, data);
+   }
+
+   void push_frame(const vit::ImgSample *s) {
+@@ -498,7 +537,7 @@
+     if (i == cam_count - 1) {
+       partial_frame->addTime("frames_read");
+       partial_frame->addTime("frames_pushed");
+-      image_data_queue->push(partial_frame);
+      push_latest(*image_data_queue, partial_frame);
+       if (show_gui) ui.update_last_image(partial_frame);
+       if (deterministic) pop_state();
+     }
+@@ -609,7 +648,6 @@
+ }
+
+ vit::Result Tracker::stop() {
+-  impl_->finalize();
+   impl_->stop();
+   return vit::Result::VIT_SUCCESS;
+ }
+@@ -718,3 +756,8 @@
+
+   return VIT_SUCCESS;
+ }
+
+// Optional Monado capability. This build joins flow/VIO before destroying their
+// connected queues and accepts shutdown sentinels while waiting for IMU.
+extern "C" __attribute__((visibility("default"))) bool
+vit_tracker_supports_safe_recreation() { return true; }
+--- a/include/basalt/optical_flow/optical_flow.h
+++ b/include/basalt/optical_flow/optical_flow.h
+@@ -128,7 +128,11 @@
+     // patch_coord = PatchT::pattern2.template cast<float>();
+     depth_guess = config.optical_flow_matching_default_depth;
+   }
+-  virtual ~OpticalFlowBase() { processing_thread->join(); }
+  virtual ~OpticalFlowBase() { maybe_join(); }
+
+  void maybe_join() {
+    if (processing_thread && processing_thread->joinable()) processing_thread->join();
+  }
+
+   virtual void processingLoop() = 0;
+
+--- a/src/vi_estimator/sqrt_keypoint_vio.cpp
+++ b/src/vi_estimator/sqrt_keypoint_vio.cpp
+@@ -60,6 +60,7 @@
+                                                             const VioConfig& config_)
+     : take_kf(true),
+       frames_after_kf(0),
+      take_ltkf(false),
+       g(g_.cast<Scalar>()),
+       initialized(false),
+       schedule_reset(false),
+@@ -145,6 +146,7 @@
+   lmdb.clear();
+
+   take_kf = true;
+  take_ltkf = false;
+   frames_after_kf = 0;
+   kf_ids.clear();
+   ltkfs.clear();
+@@ -271,6 +273,9 @@
+           // std::cout << "Skipping IMU data.." << std::endl;
+         }
+
+        // A shutdown sentinel abandons this frame instead of dereferencing it.
+        if (!data) break;
+
+         Vec3 vel_w_i_init;
+         vel_w_i_init.setZero();
+
+@@ -318,6 +323,9 @@
+           data->accel = calib.calib_accel_bias.getCalibrated(data->accel);
+           data->gyro = calib.calib_gyro_bias.getCalibrated(data->gyro);
+         }
+
+        // A shutdown sentinel abandons this frame instead of dereferencing it.
+        if (!data) break;
+
+         while (data->t_ns <= curr_frame->t_ns) {
+           meas->integrate(*data, accel_cov, gyro_cov);
+@@ -326,6 +334,9 @@
+           data->accel = calib.calib_accel_bias.getCalibrated(data->accel);
+           data->gyro = calib.calib_gyro_bias.getCalibrated(data->gyro);
+         }
+
+        // A shutdown sentinel abandons this frame instead of dereferencing it.
+        if (!data) break;
+
+         if (meas->get_start_t_ns() + meas->get_dt_ns() < curr_frame->t_ns) {
+           if (!data.get()) break;
@@ -0,0 +1,81 @@
+# Maintainer: lbgos <285507185+lbgos@users.noreply.github.com>
+pkgname=basalt-monado-rifts
+pkgver=0.1.r544.gdf6e970
+pkgrel=1
+pkgdesc='Basalt tracking library with Rift S lifecycle and worker defaults'
+arch=('x86_64')
+url='https://gitlab.freedesktop.org/mateosss/basalt'
+license=('BSD-2-Clause' 'BSD-3-Clause' 'MIT' 'BSL-1.0')
+depends=('glibc' 'libgcc' 'libstdc++' 'opencv' 'onetbb' 'fmt')
+makedepends=('cmake' 'ninja' 'git' 'eigen' 'boost')
+provides=('basalt-monado' 'basalt-monado-git')
+conflicts=('basalt-monado' 'basalt-monado-git')
+options=('!debug' '!lto')
+source=('basalt::git+https://gitlab.freedesktop.org/mateosss/basalt.git#commit=df6e970c8da7636eb401a09e3317fbeaaf829b9a'
+        'CLI11::git+https://github.com/CLIUtils/CLI11.git#commit=37bb6edc5317e99af72ef48405e65d9ca5218861'
+        'basalt-headers::git+https://gitlab.freedesktop.org/mateosss/basalt-headers.git#commit=e6db0fb84c69614bc4923fde6c52154c221c1768'
+        'opengv::git+https://github.com/laurentkneip/opengv.git#commit=91f4b19c73450833a40e463ad3648aae80b3a7f3'
+        'magic_enum::git+https://github.com/Neargye/magic_enum.git#commit=e046b69a3736d314fad813e159b1c192eaef92cd'
+        'Sophus::git+https://github.com/strasdat/Sophus.git#commit=d0b7315a0d90fc6143defa54596a3a95d9fa10ec'
+        'cereal::git+https://github.com/USCiLab/cereal.git#commit=ebef1e929807629befafbb2918ea1a08c7194554'
+        '0001-keep-imu-frequency-per-tracker.patch'
+        '0002-limit-workers-with-driver-calibration.patch'
+        '0003-safe-recreation-and-realtime-worker-budget.patch')
+sha256sums=('SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP' 'SKIP'
+            'a0bc2a766ad6ae5fdfa33cd80d45d12798d43efa4c34605ee6cf20bae157d18d' '607d53dadbd8ca5b0978d10378e631539bc8047ca0fce317b90d68a52f785a52' 'a434e76c66c129aa3a900ed151dd2dd9bc98b671451dda26855a438cff08b2ac')
+
+prepare() {
+  cd basalt
+  # Only the shared-library dependencies are needed. Use makepkg's pinned sources
+  # instead of fetching unrelated ROS/Pangolin/test submodules during prepare.
+  local module
+  for module in CLI11 basalt-headers opengv magic_enum; do
+    git submodule init "thirdparty/$module"
+    git config "submodule.thirdparty/$module.url" "$srcdir/$module"
+  done
+  git -c protocol.file.allow=always submodule update --no-fetch thirdparty/{CLI11,basalt-headers,opengv,magic_enum}
+  cd thirdparty/basalt-headers
+  for module in Sophus cereal; do
+    git submodule init "thirdparty/$module"
+    git config "submodule.thirdparty/$module.url" "$srcdir/$module"
+  done
+  git -c protocol.file.allow=always submodule update --no-fetch thirdparty/{Sophus,cereal}
+  cd ../..
+  local patchfile
+  for patchfile in "$srcdir"/000*.patch; do patch -Np1 -i "$patchfile"; done
+}
+
+build() {
+  cmake -S basalt -B build -G Ninja -DCMAKE_INSTALL_PREFIX=/usr \
+    -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTS=OFF -DBUILD_TESTING=OFF \
+    -DBASALT_INSTANTIATIONS_DOUBLE=OFF -DBASALT_BUILTIN_EIGEN=OFF \
+    -DEIGEN_ROOT=/usr/include/eigen3 -DBASALT_BUILD_SHARED_LIBRARY_ONLY=ON \
+    -DBASALT_ENABLE_ROSBAG2=OFF -DBASALT_BUILD_VISUALIZATION=OFF \
+    -DCXX_MARCH=x86-64 -DCMAKE_POLICY_VERSION_MINIMUM=3.5
+  cmake --build build --parallel 1
+}
+
+check() {
+  # Reconnect requires this capability; an unpatched Basalt build is insufficient.
+  nm -D build/libbasalt.so | grep -Eq ' T vit_tracker_supports_safe_recreation(@|$)'
+}
+
+package() {
+  DESTDIR="$pkgdir" cmake --install build
+  install -Dm644 basalt/LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+  local item
+  for item in thirdparty/basalt-headers/LICENSE \
+              thirdparty/basalt-headers/thirdparty/Sophus/LICENSE.txt \
+              thirdparty/basalt-headers/thirdparty/cereal/LICENSE \
+              thirdparty/CLI11/LICENSE thirdparty/magic_enum/LICENSE \
+              thirdparty/basalt-headers/thirdparty/cereal/include/cereal/external/LICENSE \
+              thirdparty/basalt-headers/thirdparty/cereal/include/cereal/external/rapidxml/license.txt \
+              thirdparty/basalt-headers/thirdparty/cereal/include/cereal/external/rapidjson/LICENSE \
+              thirdparty/basalt-headers/thirdparty/cereal/include/cereal/external/rapidjson/msinttypes/LICENSE \
+              thirdparty/opengv/License.txt thirdparty/vit/LICENSE; do
+    install -Dm644 "basalt/$item" "$pkgdir/usr/share/licenses/$pkgname/$item"
+  done
+  # The amalgamated header contains the JSON library and embedded-code notices.
+  install -Dm644 basalt/thirdparty/json/nlohmann/json.hpp \
+    "$pkgdir/usr/share/licenses/$pkgname/json-source-notices.hpp"
+}
@@ -0,0 +1,78 @@
+pkgbase = rift-s-linux-bin
+	pkgdesc = Oculus Rift S on Linux SteamVR: driver, Room Setup, Settings app and in-headset desktop (prebuilt)
+	pkgver = 30
+	pkgrel = 1
+	url = https://github.com/lbgos/rift-s-linux
+	install = rift-s-linux.install
+	arch = x86_64
+	license = BSL-1.0
+	license = MIT
+	license = BSD-2-Clause
+	license = BSD-3-Clause
+	license = OFL-1.1
+	license = Apache-2.0
+	license = CC-BY-4.0
+	license = CC0-1.0
+	license = Unlicense
+	license = Zlib
+	license = ISC
+	license = MPL-2.0
+	license = Unicode-3.0
+	license = Apache-2.0 WITH LLVM-exception
+	license = LicenseRef-Khronos-Free-Use-License-for-Software-and-Documentation
+	depends = glibc
+	depends = libgcc
+	depends = libstdc++
+	depends = libusb
+	depends = opencv
+	depends = onetbb
+	depends = fmt
+	depends = sdl2
+	depends = libglvnd
+	depends = vulkan-icd-loader
+	depends = libx11
+	depends = libxcb
+	depends = libxrandr
+	depends = wayland
+	depends = libdrm
+	depends = systemd-libs
+	depends = libpipewire
+	depends = cjson
+	depends = python
+	depends = libcap
+	depends = systemd
+	depends = util-linux
+	depends = procps-ng
+	depends = coreutils
+	depends = tar
+	depends = webkit2gtk-4.1
+	depends = gtk3
+	depends = cairo
+	depends = libsoup3
+	depends = gdk-pixbuf2
+	depends = glib2
+	depends = dbus
+	depends = hicolor-icon-theme
+	optdepends = steam: install and run SteamVR from the Steam library (native installation)
+	optdepends = kwin: in-headset Desktop overlay and minimized VR View preview source
+	optdepends = kconfig: write the VR View window rule (kwriteconfig6)
+	optdepends = qt6-tools: apply the VR View window rule (qdbus6)
+	provides = rift-s-linux
+	provides = monado
+	provides = rifts-settings
+	provides = basalt-monado-rifts
+	provides = basalt-monado
+	conflicts = rift-s-linux
+	conflicts = monado
+	conflicts = monado-git
+	conflicts = rifts-settings
+	conflicts = basalt-monado-rifts
+	conflicts = basalt-monado
+	conflicts = basalt-monado-git
+	conflicts = monado-rifts-git
+	options = !strip
+	options = !debug
+	source = https://github.com/lbgos/rift-s-linux/releases/download/r30/rift-s-linux-r30-x86_64.tar.zst
+	sha256sums = 6a4ff30493b8ee42acd4187fae2ea27bd01063b6c7e106e0c1494609302ef501
+
+pkgname = rift-s-linux-bin
@@ -0,0 +1,32 @@
+# Maintainer: lbgos <285507185+lbgos@users.noreply.github.com>
+pkgname=rift-s-linux-bin
+pkgver=30
+pkgrel=1
+pkgdesc='Oculus Rift S on Linux SteamVR: driver, Room Setup, Settings app and in-headset desktop (prebuilt)'
+arch=('x86_64')
+url='https://github.com/lbgos/rift-s-linux'
+license=('BSL-1.0' 'MIT' 'BSD-2-Clause' 'BSD-3-Clause' 'OFL-1.1' 'Apache-2.0' 'CC-BY-4.0'
+         'CC0-1.0' 'Unlicense' 'Zlib' 'ISC' 'MPL-2.0' 'Unicode-3.0'
+         'Apache-2.0 WITH LLVM-exception' 'LicenseRef-Khronos-Free-Use-License-for-Software-and-Documentation')
+depends=('glibc' 'libgcc' 'libstdc++' 'libusb' 'opencv' 'onetbb' 'fmt' 'sdl2' 'libglvnd'
+         'vulkan-icd-loader' 'libx11' 'libxcb' 'libxrandr' 'wayland' 'libdrm'
+         'systemd-libs' 'libpipewire' 'cjson' 'python' 'libcap' 'systemd' 'util-linux' 'procps-ng'
+         'coreutils' 'tar' 'webkit2gtk-4.1' 'gtk3' 'cairo' 'libsoup3' 'gdk-pixbuf2' 'glib2' 'dbus'
+         'hicolor-icon-theme')
+optdepends=('steam: install and run SteamVR from the Steam library (native installation)'
+            'kwin: in-headset Desktop overlay and minimized VR View preview source'
+            'kconfig: write the VR View window rule (kwriteconfig6)'
+            'qt6-tools: apply the VR View window rule (qdbus6)')
+# Bundles the patched Basalt tracking library that rift-s-linux-git takes from basalt-monado-rifts.
+provides=('rift-s-linux' 'monado' 'rifts-settings' 'basalt-monado-rifts' 'basalt-monado')
+conflicts=('rift-s-linux' 'monado' 'monado-git' 'rifts-settings' 'basalt-monado-rifts' 'basalt-monado'
+           'basalt-monado-git' 'monado-rifts-git')
+install=rift-s-linux.install
+options=('!strip' '!debug')
+source=("https://github.com/lbgos/rift-s-linux/releases/download/r$pkgver/rift-s-linux-r$pkgver-x86_64.tar.zst")
+sha256sums=('6a4ff30493b8ee42acd4187fae2ea27bd01063b6c7e106e0c1494609302ef501')
+
+package() {
+  cp -a usr "$pkgdir/"
+  mv "$pkgdir/usr/share/licenses/rift-s-linux" "$pkgdir/usr/share/licenses/$pkgname"
+}
@@ -0,0 +1,31 @@
+post_install() {
+  /usr/lib/rifts-session-install || return 1
+  udevadm control --reload-rules || true
+  echo 'Reconnect the Rift S. If Steam is running, restart it once, then start SteamVR.'
+  echo 'Driver registration runs automatically in desktop user sessions.'
+}
+
+post_upgrade() { post_install; }
+
+pre_remove() {
+  # Stop the watcher before removing registration, or it would add the driver back.
+  loginctl list-users --no-legend 2>/dev/null | while read -r uid username rest; do
+    case "$uid" in ''|*[!0-9]*) continue ;; esac
+    [ "$uid" -ge 1000 ] && [ -S "/run/user/$uid/bus" ] || continue
+    runuser -u "$username" -- env "XDG_RUNTIME_DIR=/run/user/$uid" \
+      systemctl --user stop rifts-steamvr-registration.service || continue
+    runuser -u "$username" -- env "XDG_RUNTIME_DIR=/run/user/$uid" \
+      /usr/bin/rifts-setup uninstall || true
+  done
+}
+
+post_remove() {
+  udevadm control --reload-rules || true
+  loginctl list-users --no-legend 2>/dev/null | while read -r uid username rest; do
+    case "$uid" in ''|*[!0-9]*) continue ;; esac
+    [ "$uid" -ge 1000 ] && [ -S "/run/user/$uid/bus" ] || continue
+    runuser -u "$username" -- env "XDG_RUNTIME_DIR=/run/user/$uid" systemctl --user daemon-reload
+  done
+  echo 'Users without a reachable user session may retain a stale SteamVR driver path.'
+  echo 'Remove /usr/share/steamvr-monado with SteamVR vrpathreg removedriver if needed.'
+}
@@ -0,0 +1,94 @@
+pkgbase = rift-s-linux-git
+	pkgdesc = Oculus Rift S on Linux SteamVR: driver, Room Setup, Settings app and in-headset desktop
+	pkgver = 25.1.0.r8702.gd82b8cbda
+	pkgrel = 1
+	url = https://github.com/lbgos/rift-s-linux
+	install = rift-s-linux.install
+	arch = x86_64
+	license = BSL-1.0
+	license = MIT
+	license = BSD-2-Clause
+	license = BSD-3-Clause
+	license = OFL-1.1
+	license = Apache-2.0
+	license = CC-BY-4.0
+	license = CC0-1.0
+	license = Unlicense
+	license = Zlib
+	license = ISC
+	license = MPL-2.0
+	license = Unicode-3.0
+	license = Apache-2.0 WITH LLVM-exception
+	license = LicenseRef-Khronos-Free-Use-License-for-Software-and-Documentation
+	makedepends = git
+	makedepends = cmake
+	makedepends = ninja
+	makedepends = eigen
+	makedepends = glslang
+	makedepends = vulkan-headers
+	makedepends = wayland-protocols
+	makedepends = plasma-wayland-protocols
+	makedepends = pipewire
+	makedepends = cargo
+	makedepends = pnpm
+	makedepends = nodejs
+	makedepends = pkgconf
+	makedepends = shaderc
+	makedepends = desktop-file-utils
+	depends = glibc
+	depends = libgcc
+	depends = libstdc++
+	depends = libusb
+	depends = opencv
+	depends = sdl2
+	depends = libglvnd
+	depends = vulkan-icd-loader
+	depends = libx11
+	depends = libxcb
+	depends = libxrandr
+	depends = wayland
+	depends = libdrm
+	depends = systemd-libs
+	depends = libpipewire
+	depends = cjson
+	depends = python
+	depends = libcap
+	depends = systemd
+	depends = util-linux
+	depends = procps-ng
+	depends = coreutils
+	depends = tar
+	depends = basalt-monado-rifts
+	depends = webkit2gtk-4.1
+	depends = gtk3
+	depends = cairo
+	depends = libsoup3
+	depends = gdk-pixbuf2
+	depends = glib2
+	depends = dbus
+	depends = hicolor-icon-theme
+	optdepends = steam: install and run SteamVR from the Steam library (native installation)
+	optdepends = kwin: in-headset Desktop overlay and minimized VR View preview source
+	optdepends = kconfig: write the VR View window rule (kwriteconfig6)
+	optdepends = qt6-tools: apply the VR View window rule (qdbus6)
+	provides = rift-s-linux
+	provides = monado
+	provides = monado-git
+	provides = rifts-settings
+	conflicts = rift-s-linux
+	conflicts = monado
+	conflicts = monado-git
+	conflicts = rifts-settings
+	conflicts = monado-rifts-git
+	options = !debug
+	options = !lto
+	source = monado::git+https://github.com/lbgos/rift-s-linux.git#branch=main
+	source = 70-monado-rifts.rules
+	source = settings-licenses.py
+	source = settings-license-fallbacks.json
+	sha256sums = SKIP
+	sha256sums = 3fbda3da3bb6fdd909d6a507a1a49ede88479ab47e5b7bf88aba6d5365005ba6
+	sha256sums = f3eaa7437858d201c5e48c6ec62e38a28c5286112d6a994a695821db78462c2b
+	sha256sums = 2093d3111612e01f10ea0d0478d100faea010edaa738997d2e4866a7072c1e06
+
+pkgname = rift-s-linux-git
@@ -0,0 +1,4 @@
+# Oculus USB devices, including Rift S HMD/cameras and hidraw interfaces.
+# Seat access only; do not grant all users world-writable USB access.
+SUBSYSTEM=="usb", ATTRS{idVendor}=="2833", TAG+="uaccess"
+KERNEL=="hidraw*", ATTRS{idVendor}=="2833", TAG+="uaccess"
@@ -0,0 +1,119 @@
+# Maintainer: lbgos <285507185+lbgos@users.noreply.github.com>
+pkgname=rift-s-linux-git
+pkgver=25.1.0.r8702.gd82b8cbda
+pkgrel=1
+pkgdesc='Oculus Rift S on Linux SteamVR: driver, Room Setup, Settings app and in-headset desktop'
+arch=('x86_64')
+url='https://github.com/lbgos/rift-s-linux'
+license=('BSL-1.0' 'MIT' 'BSD-2-Clause' 'BSD-3-Clause' 'OFL-1.1' 'Apache-2.0' 'CC-BY-4.0'
+         'CC0-1.0' 'Unlicense' 'Zlib' 'ISC' 'MPL-2.0' 'Unicode-3.0'
+         'Apache-2.0 WITH LLVM-exception' 'LicenseRef-Khronos-Free-Use-License-for-Software-and-Documentation')
+depends=('glibc' 'libgcc' 'libstdc++' 'libusb' 'opencv' 'sdl2' 'libglvnd'
+         'vulkan-icd-loader' 'libx11' 'libxcb' 'libxrandr' 'wayland' 'libdrm'
+         'systemd-libs' 'libpipewire' 'cjson' 'python' 'libcap' 'systemd' 'util-linux' 'procps-ng' 'coreutils' 'tar'
+         'basalt-monado-rifts' 'webkit2gtk-4.1' 'gtk3' 'cairo'
+         'libsoup3' 'gdk-pixbuf2' 'glib2' 'dbus' 'hicolor-icon-theme')
+optdepends=('steam: install and run SteamVR from the Steam library (native installation)'
+            'kwin: in-headset Desktop overlay and minimized VR View preview source'
+            'kconfig: write the VR View window rule (kwriteconfig6)'
+            'qt6-tools: apply the VR View window rule (qdbus6)')
+makedepends=('git' 'cmake' 'ninja' 'eigen' 'glslang' 'vulkan-headers'
+             'wayland-protocols' 'plasma-wayland-protocols' 'pipewire' 'cargo' 'pnpm' 'nodejs' 'pkgconf' 'shaderc'
+             'desktop-file-utils')
+provides=('rift-s-linux' 'monado' 'monado-git' 'rifts-settings')
+conflicts=('rift-s-linux' 'monado' 'monado-git' 'rifts-settings' 'monado-rifts-git')
+install=rift-s-linux.install
+options=('!debug' '!lto')
+source=('monado::git+https://github.com/lbgos/rift-s-linux.git#branch=main'
+        '70-monado-rifts.rules' 'settings-licenses.py' 'settings-license-fallbacks.json')
+sha256sums=('SKIP' '3fbda3da3bb6fdd909d6a507a1a49ede88479ab47e5b7bf88aba6d5365005ba6' 'f3eaa7437858d201c5e48c6ec62e38a28c5286112d6a994a695821db78462c2b' '2093d3111612e01f10ea0d0478d100faea010edaa738997d2e4866a7072c1e06')
+
+pkgver() {
+  cd monado
+  printf '25.1.0.r%s.g%s' "$(git rev-list --count HEAD)" "$(git rev-parse --short=9 HEAD)"
+}
+
+prepare() {
+  cd monado/settings-app
+  # Fetch locked dependencies before the build; both compilers then run offline.
+  pnpm fetch --frozen-lockfile --store-dir "$srcdir/pnpm-store"
+  cargo fetch --manifest-path src-tauri/Cargo.toml --locked --target x86_64-unknown-linux-gnu
+}
+
+build() {
+  local drivers=() option
+  # Keep optional host libraries from enabling unrelated hardware drivers.
+  while read -r option; do drivers+=("-D${option}=OFF"); done < <(
+    sed -n 's/.*(\(XRT_BUILD_DRIVER_[A-Z0-9_]*\) .*/\1/p' monado/CMakeLists.txt)
+  cmake -S monado -B build -G Ninja \
+    -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr \
+    -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_INSTALL_LIBEXECDIR=lib \
+    -DBUILD_TESTING=ON -DXRT_BUILD_SAMPLES=OFF "${drivers[@]}" \
+    -DXRT_BUILD_DRIVER_RIFT_S=ON -DXRT_BUILD_DRIVER_SIMULATED=ON \
+    -DXRT_FEATURE_STEAMVR_PLUGIN=ON -DXRT_FEATURE_SLAM=ON \
+    -DXRT_HAVE_SYSTEM_CJSON=ON -DXRT_HAVE_GST=OFF -DXRT_HAVE_BLUETOOTH=OFF \
+    -DXRT_HAVE_DBUS=OFF -DXRT_HAVE_HIDAPI=OFF -DXRT_HAVE_JPEG=OFF -DXRT_HAVE_LIBBSD=OFF \
+    -DXRT_HAVE_LIBUVC=OFF -DXRT_HAVE_OPENVR=OFF -DXRT_MODULE_MERCURY_HANDTRACKING=OFF \
+    -DRIFTS_DESKTOP_OVERLAY=ON
+  cmake --build build --parallel 2
+
+  cd monado/settings-app
+  pnpm install --offline --frozen-lockfile --store-dir "$srcdir/pnpm-store"
+  pnpm build
+  # custom-protocol embeds the built frontend instead of using the dev server.
+  cargo build --manifest-path src-tauri/Cargo.toml --release --frozen --features custom-protocol -j2
+  cargo metadata --manifest-path src-tauri/Cargo.toml --frozen --features custom-protocol --format-version 1 \
+    --filter-platform x86_64-unknown-linux-gnu > "$srcdir/settings-rust-metadata.json"
+  pnpm licenses list --prod --json > "$srcdir/settings-js-metadata.json"
+  python "$srcdir/settings-licenses.py" "$srcdir/settings-rust-metadata.json" \
+    "$srcdir/settings-js-metadata.json" "$srcdir/settings-license-fallbacks.json" > "$srcdir/settings-third-party-notices.txt"
+}
+
+check() {
+  VIT_SYSTEM_LIBRARY_PATH=/usr/lib/libbasalt.so ctest --test-dir build --output-on-failure
+  cd monado/settings-app
+  cargo test --manifest-path src-tauri/Cargo.toml --release --frozen --features custom-protocol -j2
+}
+
+package() {
+  DESTDIR="$pkgdir" cmake --install build
+  # CMake skips the overlay with only a warning when its dependencies are missing.
+  test -x "$pkgdir/usr/bin/rifts-desktop"
+  # SteamVR needs this layout; executable code belongs under /usr/lib on Arch.
+  install -d "$pkgdir/usr/lib/steamvr-monado"
+  mv "$pkgdir/usr/share/steamvr-monado/bin" "$pkgdir/usr/lib/steamvr-monado/bin"
+  ln -s ../../lib/steamvr-monado/bin "$pkgdir/usr/share/steamvr-monado/bin"
+  sed -i 's|/usr/share/steamvr-monado/bin/|/usr/lib/steamvr-monado/bin/|' \
+    "$pkgdir/usr/share/vulkan/implicit_layer.d/monado_roomsetup_vulkan.json"
+  install -Dm644 "$srcdir/70-monado-rifts.rules" "$pkgdir/usr/lib/udev/rules.d/70-monado-rifts.rules"
+
+  local app=monado/settings-app
+  install -Dm755 "$app/src-tauri/target/release/rifts-settings" "$pkgdir/usr/bin/rifts-settings"
+  install -Dm644 "$app/rifts-settings.desktop" "$pkgdir/usr/share/applications/rifts-settings.desktop"
+  sed -i -e 's|^Exec=.*|Exec=/usr/bin/rifts-settings|' -e 's|^Icon=.*|Icon=rifts-settings|' \
+    "$pkgdir/usr/share/applications/rifts-settings.desktop"
+  desktop-file-validate "$pkgdir/usr/share/applications/rifts-settings.desktop"
+  install -Dm644 "$app/src-tauri/icons/icon.png" "$pkgdir/usr/share/icons/hicolor/128x128/apps/rifts-settings.png"
+  # Settings applies this per-user KWin rule when the full-resolution preview is enabled.
+  install -Dm755 "$app/install-vrview-rule.sh" "$pkgdir/usr/share/rifts-settings/install-vrview-rule.sh"
+  install -Dm644 "$app/vrview.kwinrule" "$pkgdir/usr/share/rifts-settings/vrview.kwinrule"
+
+  install -Dm644 monado/LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+  install -d "$pkgdir/usr/share/licenses/$pkgname/Monado"
+  install -m644 monado/LICENSES/*.txt "$pkgdir/usr/share/licenses/$pkgname/Monado/"
+  local notice
+  while IFS= read -r -d '' notice; do
+    install -Dm644 "$notice" "$pkgdir/usr/share/licenses/$pkgname/${notice#monado/}"
+  done < <(find monado/src/external -type f \( -iname LICENSE -o -iname LICENSE.txt -o -iname COPYING -o -iname '*.license' \) -print0)
+  # These single-file libraries keep their grants and copyright notices inline.
+  for notice in monado/src/external/bcdec/bcdec.h monado/src/external/stb/stb_image_write.h \
+                monado/src/external/imgui/imgui/imstb*.h \
+                monado/src/external/glad/include/{KHR/khrplatform,EGL/eglplatform}.h; do
+    install -Dm644 "$notice" "$pkgdir/usr/share/licenses/$pkgname/${notice#monado/}"
+  done
+  install -Dm644 monado/src/external/openvr_includes/LICENSE "$pkgdir/usr/share/licenses/$pkgname/OpenVR"
+  install -Dm644 "$app/LICENSE" "$pkgdir/usr/share/licenses/$pkgname/Settings-MIT"
+  install -Dm644 "$app/src/fonts/OFL.txt" "$pkgdir/usr/share/licenses/$pkgname/OpenSans-OFL"
+  install -Dm644 "$app/src-tauri/native/OpenVR-LICENSE" "$pkgdir/usr/share/licenses/$pkgname/Settings-OpenVR"
+  install -Dm644 "$srcdir/settings-third-party-notices.txt" "$pkgdir/usr/share/licenses/$pkgname/Settings-third-party-notices.txt"
+}
@@ -0,0 +1,31 @@
+post_install() {
+  /usr/lib/rifts-session-install || return 1
+  udevadm control --reload-rules || true
+  echo 'Reconnect the Rift S. If Steam is running, restart it once, then start SteamVR.'
+  echo 'Driver registration runs automatically in desktop user sessions.'
+}
+
+post_upgrade() { post_install; }
+
+pre_remove() {
+  # Stop the watcher before removing registration, or it would add the driver back.
+  loginctl list-users --no-legend 2>/dev/null | while read -r uid username rest; do
+    case "$uid" in ''|*[!0-9]*) continue ;; esac
+    [ "$uid" -ge 1000 ] && [ -S "/run/user/$uid/bus" ] || continue
+    runuser -u "$username" -- env "XDG_RUNTIME_DIR=/run/user/$uid" \
+      systemctl --user stop rifts-steamvr-registration.service || continue
+    runuser -u "$username" -- env "XDG_RUNTIME_DIR=/run/user/$uid" \
+      /usr/bin/rifts-setup uninstall || true
+  done
+}
+
+post_remove() {
+  udevadm control --reload-rules || true
+  loginctl list-users --no-legend 2>/dev/null | while read -r uid username rest; do
+    case "$uid" in ''|*[!0-9]*) continue ;; esac
+    [ "$uid" -ge 1000 ] && [ -S "/run/user/$uid/bus" ] || continue
+    runuser -u "$username" -- env "XDG_RUNTIME_DIR=/run/user/$uid" systemctl --user daemon-reload
+  done
+  echo 'Users without a reachable user session may retain a stale SteamVR driver path.'
+  echo 'Remove /usr/share/steamvr-monado with SteamVR vrpathreg removedriver if needed.'
+}
@@ -0,0 +1,26 @@
+{
+  "alloc-stdlib@0.3.0": {
+    "source": "https://raw.githubusercontent.com/dropbox/rust-alloc-no-stdlib/0a81fd6928ea3b33c8cd484aa4575d50ffb98012/LICENSE",
+    "notice": "Copyright (c) 2016 Dropbox, Inc.\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
+  },
+  "defmt-parser@1.0.0": {
+    "source": "https://raw.githubusercontent.com/knurling-rs/defmt/4a8cdb44891ed57b8ff5a023b6bec7137c48708f/LICENSE-MIT",
+    "notice": "Copyright (c) Ferrous Systems\n\nPermission is hereby granted, free of charge, to any\nperson obtaining a copy of this software and associated\ndocumentation files (the \"Software\"), to deal in the\nSoftware without restriction, including without\nlimitation the rights to use, copy, modify, merge,\npublish, distribute, sublicense, and/or sell copies of\nthe Software, and to permit persons to whom the Software\nis furnished to do so, subject to the following\nconditions:\n\nThe above copyright notice and this permission notice\nshall be included in all copies or substantial portions\nof the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF\nANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\nTO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\nPARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\nSHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR\nIN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE."
+  },
+  "dlopen2@0.8.2": {
+    "source": "https://raw.githubusercontent.com/OpenByteDev/dlopen2/cc80e4a0a90d499b677fdf7743699b4b3a43a989/LICENSE",
+    "notice": "MIT License\n\nCopyright (c) 2017 Szymon Wieloch\nCopyright (C) 2019 Ahmed Masud <ahmed.masud@saf.ai>\nCopyright (C) 2022 OpenByte <development.openbyte@gmail.com>\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
+  },
+  "dlopen2_derive@0.4.3": {
+    "source": "https://raw.githubusercontent.com/OpenByteDev/dlopen2/cc80e4a0a90d499b677fdf7743699b4b3a43a989/LICENSE",
+    "notice": "MIT License\n\nCopyright (c) 2017 Szymon Wieloch\nCopyright (C) 2019 Ahmed Masud <ahmed.masud@saf.ai>\nCopyright (C) 2022 OpenByte <development.openbyte@gmail.com>\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
+  },
+  "libappindicator-sys@0.9.0": {
+    "source": "https://raw.githubusercontent.com/tauri-apps/libappindicator-rs/eafd1e3682a1247f595410266091e9684021cb6f/LICENSE-MIT",
+    "notice": "MIT License\n\nCopyright (c) 2017-2021 qDot\nCopyright (c) 2021 Tauri Apps Contributors\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
+  },
+  "selectors@0.38.0": {
+    "source": "https://www.mozilla.org/media/MPL/2.0/index.txt",
+    "notice": "Mozilla Public License Version 2.0\n==================================\n\n1. Definitions\n--------------\n\n1.1. \"Contributor\"\n    means each individual or legal entity that creates, contributes to\n    the creation of, or owns Covered Software.\n\n1.2. \"Contributor Version\"\n    means the combination of the Contributions of others (if any) used\n    by a Contributor and that particular Contributor's Contribution.\n\n1.3. \"Contribution\"\n    means Covered Software of a particular Contributor.\n\n1.4. \"Covered Software\"\n    means Source Code Form to which the initial Contributor has attached\n    the notice in Exhibit A, the Executable Form of such Source Code\n    Form, and Modifications of such Source Code Form, in each case\n    including portions thereof.\n\n1.5. \"Incompatible With Secondary Licenses\"\n    means\n\n    (a) that the initial Contributor has attached the notice described\n        in Exhibit B to the Covered Software; or\n\n    (b) that the Covered Software was made available under the terms of\n        version 1.1 or earlier of the License, but not also under the\n        terms of a Secondary License.\n\n1.6. \"Executable Form\"\n    means any form of the work other than Source Code Form.\n\n1.7. \"Larger Work\"\n    means a work that combines Covered Software with other material, in\n    a separate file or files, that is not Covered Software.\n\n1.8. \"License\"\n    means this document.\n\n1.9. \"Licensable\"\n    means having the right to grant, to the maximum extent possible,\n    whether at the time of the initial grant or subsequently, any and\n    all of the rights conveyed by this License.\n\n1.10. \"Modifications\"\n    means any of the following:\n\n    (a) any file in Source Code Form that results from an addition to,\n        deletion from, or modification of the contents of Covered\n        Software; or\n\n    (b) any new file in Source Code Form that contains any Covered\n        Software.\n\n1.11. \"Patent Claims\" of a Contributor\n    means any patent claim(s), including without limitation, method,\n    process, and apparatus claims, in any patent Licensable by such\n    Contributor that would be infringed, but for the grant of the\n    License, by the making, using, selling, offering for sale, having\n    made, import, or transfer of either its Contributions or its\n    Contributor Version.\n\n1.12. \"Secondary License\"\n    means either the GNU General Public License, Version 2.0, the GNU\n    Lesser General Public License, Version 2.1, the GNU Affero General\n    Public License, Version 3.0, or any later versions of those\n    licenses.\n\n1.13. \"Source Code Form\"\n    means the form of the work preferred for making modifications.\n\n1.14. \"You\" (or \"Your\")\n    means an individual or a legal entity exercising rights under this\n    License. For legal entities, \"You\" includes any entity that\n    controls, is controlled by, or is under common control with You. For\n    purposes of this definition, \"control\" means (a) the power, direct\n    or indirect, to cause the direction or management of such entity,\n    whether by contract or otherwise, or (b) ownership of more than\n    fifty percent (50%) of the outstanding shares or beneficial\n    ownership of such entity.\n\n2. License Grants and Conditions\n--------------------------------\n\n2.1. Grants\n\nEach Contributor hereby grants You a world-wide, royalty-free,\nnon-exclusive license:\n\n(a) under intellectual property rights (other than patent or trademark)\n    Licensable by such Contributor to use, reproduce, make available,\n    modify, display, perform, distribute, and otherwise exploit its\n    Contributions, either on an unmodified basis, with Modifications, or\n    as part of a Larger Work; and\n\n(b) under Patent Claims of such Contributor to make, use, sell, offer\n    for sale, have made, import, and otherwise transfer either its\n    Contributions or its Contributor Version.\n\n2.2. Effective Date\n\nThe licenses granted in Section 2.1 with respect to any Contribution\nbecome effective for each Contribution on the date the Contributor first\ndistributes such Contribution.\n\n2.3. Limitations on Grant Scope\n\nThe licenses granted in this Section 2 are the only rights granted under\nthis License. No additional rights or licenses will be implied from the\ndistribution or licensing of Covered Software under this License.\nNotwithstanding Section 2.1(b) above, no patent license is granted by a\nContributor:\n\n(a) for any code that a Contributor has removed from Covered Software;\n    or\n\n(b) for infringements caused by: (i) Your and any other third party's\n    modifications of Covered Software, or (ii) the combination of its\n    Contributions with other software (except as part of its Contributor\n    Version); or\n\n(c) under Patent Claims infringed by Covered Software in the absence of\n    its Contributions.\n\nThis License does not grant any rights in the trademaLine truncated
+  }
+}
@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""Collect locked Settings dependencies' declarations and bundled notices."""
+import json
+from pathlib import Path
+import sys
+
+
+fallbacks = json.loads(Path(sys.argv[3]).read_text())
+
+
+def emit(name, version, license_id, roots, license_file=None, source=None):
+    print(f"\n{name} {version}\nLicense: {license_id or 'See bundled notice'}\n")
+    if source:
+        print(f"Source: {source}\n")
+    notices = set()
+    for root in roots:
+        root = Path(root)
+        for item in root.rglob('*'):
+            if item.name.lower().startswith(('license', 'licence', 'copying', 'copyright', 'notice')):
+                if item.is_file():
+                    notices.add(item)
+                elif item.is_dir():
+                    notices.update(p for p in item.rglob('*') if p.is_file())
+        if license_file:
+            notices.add(root / license_file)
+    for notice in sorted(notices):
+        print(f"--- {notice.relative_to(next(Path(root) for root in roots if notice.is_relative_to(root)))} ---")
+        print(notice.read_text(encoding='utf-8', errors='replace'))
+    if not notices:
+        fallback = fallbacks.get(f'{name}@{version}')
+        if not fallback:
+            raise SystemExit(f'Missing license notice for {name} {version}')
+        print(f"Notice source: {fallback['source']}\n")
+        print(fallback['notice'])
+
+
+rust = json.loads(Path(sys.argv[1]).read_text())
+resolved = {node['id'] for node in rust['resolve']['nodes']}
+for package in sorted(rust['packages'], key=lambda p: (p['name'], p['version'])):
+    # The application's own MIT notice is installed separately.
+    if package['id'] in resolved and package['id'] not in rust['workspace_members']:
+        emit(package['name'], package['version'], package['license'],
+             [Path(package['manifest_path']).parent], package.get('license_file'),
+             f"https://crates.io/api/v1/crates/{package['name']}/{package['version']}/download")
+
+javascript = json.loads(Path(sys.argv[2]).read_text())
+for packages in javascript.values():
+    for package in sorted(packages, key=lambda p: p['name']):
+        emit(package['name'], ', '.join(package['versions']), package['license'], package['paths'])
@@ -0,0 +1,43 @@
+# Universal x86_64 build
+
+A tarball for non-Arch distributions. `install.sh` puts everything under
+`~/.local/share/rift-s-linux`, which SteamVR also sees inside the Steam Linux
+Runtime container, so the driver needs no SteamVR launch option. Only the udev
+rule needs root.
+
+The driver, Basalt and their libraries are built in the Steam Runtime sniper SDK
+(Debian 11, glibc 2.31) and bundle Basalt, oneTBB and a trimmed OpenCV. The
+Settings app needs webkit2gtk 4.1, which the SDK lacks, so it is built in an
+Ubuntu 22.04 root (glibc 2.35).
+
+## Layout
+
+`work/` is bind-mounted at `/work` in both roots:
+
+- `src/monado` this repository
+- `src/basalt` Basalt prepared by `packaging/aur/basalt-monado-rifts` (`makepkg -o`)
+- `src/{opencv-4.12.0,oneTBB-2022.2.0,fmt-11.2.0}` upstream release tarballs
+- `hostdeps/usr` header-only build deps extracted from the Arch packages
+  `boost`, `eigen`, `vulkan-headers`, `plasma-wayland-protocols`
+
+`sysroot/` is `com.valvesoftware.SteamRuntime.Sdk-amd64,i386-sniper-sysroot.tar.gz`
+from `repo.steampowered.com/steamrt-images-sniper/snapshots/`. `sdk` runs a
+command in it with bwrap.
+
+The Ubuntu root needs `build-essential pkg-config libwebkit2gtk-4.1-dev
+libgtk-3-dev libsoup-3.0-dev libvulkan-dev libwayland-dev glslang-tools
+python3`, rustup, Node 22 and pnpm 10. Ubuntu 22.04 has no `glslc` package; a
+wrapper around `glslangValidator -V -x` that adds the surrounding braces is enough
+for `settings-app/src-tauri/build.rs`.
+
+## Build
+
+```sh
+./sdk /work/src/monado/packaging/universal/deps.sh      # once
+./sdk /work/src/monado/packaging/universal/build.sh
+<ubuntu root> /work/src/monado/packaging/universal/settings.sh
+packaging/universal/package.sh work <version>          # host, needs patchelf
+```
+
+The result is `work/dist/rift-s-linux-<version>-x86_64.tar.xz`. Users extract it
+and run `./install.sh`; `./install.sh --uninstall` removes it.
@@ -0,0 +1,30 @@
+#!/bin/sh
+# Build Basalt and rift-s-linux against the bundled deps; stage the install under /work/stage.
+set -eu
+export CC=gcc-14 CXX=g++-14
+P=/work/prefix H=/work/hostdeps/usr J=${J:-8}
+export CMAKE_PREFIX_PATH="$P:$H"
+cmake -S /work/src/basalt -B /work/build/basalt -G Ninja -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_INSTALL_PREFIX=$P -DCMAKE_INSTALL_LIBDIR=lib -DBUILD_TESTS=OFF -DBUILD_TESTING=OFF \
+  -DBASALT_INSTANTIATIONS_DOUBLE=OFF -DBASALT_BUILTIN_EIGEN=OFF -DEIGEN_ROOT=$H/include/eigen3 \
+  -DBoost_INCLUDE_DIR=$H/include -DBASALT_BUILD_SHARED_LIBRARY_ONLY=ON -DBASALT_ENABLE_ROSBAG2=OFF \
+  -DBASALT_BUILD_VISUALIZATION=OFF -DCXX_MARCH=x86-64 -DCMAKE_POLICY_VERSION_MINIMUM=3.5 \
+  -DCMAKE_INSTALL_RPATH="\$ORIGIN"
+cmake --build /work/build/basalt -j${BJ:-4} && cmake --install /work/build/basalt
+nm -D /work/build/basalt/libbasalt.so | grep -q " T vit_tracker_supports_safe_recreation"
+drivers=$(sed -n "s/.*(\(XRT_BUILD_DRIVER_[A-Z0-9_]*\) .*/-D\1=OFF/p" /work/src/monado/CMakeLists.txt | tr "\n" " ")
+# bin/ and share/steamvr-monado/bin/linux64/ both reach the bundled lib/.
+cmake -S /work/src/monado -B /work/build/monado -G Ninja -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_INSTALL_PREFIX=/opt/rift-s-linux -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_INSTALL_LIBEXECDIR=lib \
+  -DCMAKE_INSTALL_RPATH="\$ORIGIN/../lib:\$ORIGIN/../../../../lib" \
+  -DBUILD_TESTING=ON -DXRT_BUILD_SAMPLES=OFF $drivers \
+  -DXRT_BUILD_DRIVER_RIFT_S=ON -DXRT_BUILD_DRIVER_SIMULATED=ON \
+  -DXRT_FEATURE_STEAMVR_PLUGIN=ON -DXRT_FEATURE_SLAM=ON \
+  -DXRT_HAVE_SYSTEM_CJSON=OFF -DXRT_HAVE_GST=OFF -DXRT_HAVE_BLUETOOTH=OFF \
+  -DXRT_HAVE_DBUS=OFF -DXRT_HAVE_HIDAPI=OFF -DXRT_HAVE_JPEG=OFF -DXRT_HAVE_LIBBSD=OFF \
+  -DXRT_HAVE_LIBUVC=OFF -DXRT_HAVE_OPENVR=OFF -DXRT_MODULE_MERCURY_HANDTRACKING=OFF \
+  -DRIFTS_DESKTOP_OVERLAY=ON -DOpenCV_DIR=$P/lib/cmake/opencv4 -DEigen3_DIR=$H/share/eigen3/cmake
+cmake --build /work/build/monado -j$J
+VIT_SYSTEM_LIBRARY_PATH=$P/lib/libbasalt.so ctest --test-dir /work/build/monado --output-on-failure -j4
+rm -rf /work/stage && DESTDIR=/work/stage cmake --install /work/build/monado
+echo build-ok
@@ -0,0 +1,23 @@
+#!/bin/sh
+# Build the bundled third-party libraries into /work/prefix inside the sniper SDK.
+set -eu
+export CC=gcc-14 CXX=g++-14
+P=/work/prefix
+J=${J:-8}
+common="-G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=$P -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_POSITION_INDEPENDENT_CODE=ON"
+cd /work/src
+cmake -S fmt-11.2.0 -B /work/build/fmt $common -DFMT_TEST=OFF -DFMT_DOC=OFF -DBUILD_SHARED_LIBS=OFF
+cmake --build /work/build/fmt -j$J && cmake --install /work/build/fmt
+cmake -S oneTBB-2022.2.0 -B /work/build/tbb $common -DTBB_TEST=OFF -DTBB_EXAMPLES=OFF -DTBB_STRICT=OFF -DTBBMALLOC_BUILD=OFF
+cmake --build /work/build/tbb -j$J && cmake --install /work/build/tbb
+cmake -S opencv-4.12.0 -B /work/build/opencv $common \
+  -DBUILD_LIST=core,imgproc,imgcodecs,highgui,video,calib3d,features2d,flann \
+  -DWITH_QT=OFF -DWITH_GTK=OFF -DWITH_FFMPEG=OFF -DWITH_GSTREAMER=OFF -DWITH_V4L=OFF -DWITH_OPENCL=OFF \
+  -DWITH_IPP=OFF -DWITH_ITT=OFF -DWITH_PROTOBUF=OFF -DWITH_TBB=OFF -DWITH_EIGEN=OFF -DWITH_LAPACK=OFF \
+  -DWITH_TIFF=OFF -DWITH_WEBP=OFF -DWITH_OPENEXR=OFF -DWITH_OPENJPEG=OFF -DWITH_JASPER=OFF -DWITH_AVIF=OFF \
+  -DWITH_IMGCODEC_HDR=OFF -DWITH_IMGCODEC_SUNRASTER=OFF -DWITH_IMGCODEC_PXM=OFF -DWITH_IMGCODEC_PFM=OFF \
+  -DBUILD_PNG=ON -DBUILD_JPEG=ON -DBUILD_ZLIB=ON -DWITH_ADE=OFF -DWITH_VA=OFF -DWITH_1394=OFF \
+  -DBUILD_TESTS=OFF -DBUILD_PERF_TESTS=OFF -DBUILD_EXAMPLES=OFF -DBUILD_opencv_apps=OFF -DBUILD_JAVA=OFF \
+  -DBUILD_opencv_python3=OFF -DOPENCV_GENERATE_PKGCONFIG=OFF -DCPU_BASELINE=SSE3 -DOPENCV_SKIP_PYTHON_LOADER=ON
+cmake --build /work/build/opencv -j$J && cmake --install /work/build/opencv
+echo deps-ok
@@ -0,0 +1,84 @@
+#!/bin/sh
+# Install or remove the universal rift-s-linux build for the current user.
+#
+#   ./install.sh               install into ~/.local/share/rift-s-linux
+#   ./install.sh --uninstall   remove it again
+#
+# Everything lands in the user's home, which SteamVR can also see inside the Steam
+# Linux Runtime container. Only the udev rule for headset access needs root.
+set -eu
+
+BUILD_PREFIX=/opt/rift-s-linux
+here=$(cd "$(dirname "$0")" && pwd)
+data=${XDG_DATA_HOME:-$HOME/.local/share}
+config=${XDG_CONFIG_HOME:-$HOME/.config}
+prefix=$data/rift-s-linux
+units=$config/systemd/user
+service=rifts-steamvr-registration.service
+layer=$data/vulkan/implicit_layer.d/monado_roomsetup_vulkan.json
+rule=/etc/udev/rules.d/70-monado-rifts.rules
+desktop_files="rifts-steamvr.desktop rifts-desktop.desktop rifts-settings.desktop"
+
+[ "$(id -u)" -ne 0 ] || { echo 'Run as your normal user, not root.' >&2; exit 1; }
+
+as_root() {
+	if command -v sudo >/dev/null; then sudo "$@"; else pkexec "$@"; fi
+}
+
+uninstall() {
+	if [ -x "$prefix/bin/rifts-setup" ]; then
+		systemctl --user disable --now "$service" 2>/dev/null || true
+		"$prefix/bin/rifts-setup" uninstall || true
+	fi
+	rm -f "$units/$service" "$layer"
+	for file in $desktop_files; do rm -f "$data/applications/$file"; done
+	rm -rf "$prefix"
+	systemctl --user daemon-reload 2>/dev/null || true
+	if [ -e "$rule" ]; then
+		as_root rm -f "$rule" && as_root udevadm control --reload-rules || true
+	fi
+	echo 'rift-s-linux removed.'
+}
+
+if [ "${1:-}" = --uninstall ]; then
+	uninstall
+	exit
+fi
+
+if [ -d /usr/share/steamvr-monado ]; then
+	echo 'A system-wide rift-s-linux package is installed. Remove it first.' >&2
+	exit 1
+fi
+
+# Stop the running watcher before replacing its files.
+systemctl --user stop "$service" 2>/dev/null || true
+rm -rf "$prefix.new"
+mkdir -p "$prefix.new"
+cp -a "$here/files/." "$prefix.new/"
+# Text files carry the build prefix; binaries locate their files at run time.
+grep -rlI --null "$BUILD_PREFIX" "$prefix.new" | xargs -0 -r sed -i "s|$BUILD_PREFIX|$prefix|g"
+rm -rf "$prefix"
+mv "$prefix.new" "$prefix"
+
+mkdir -p "$units" "$(dirname "$layer")" "$data/applications"
+cp "$prefix/lib/systemd/user/$service" "$units/$service"
+cp "$prefix/share/vulkan/implicit_layer.d/monado_roomsetup_vulkan.json" "$layer"
+for file in $desktop_files; do
+	if [ -f "$prefix/share/applications/$file" ]; then cp "$prefix/share/applications/$file" "$data/applications/$file"; fi
+done
+
+if ! cmp -s "$prefix/share/udev/70-monado-rifts.rules" "$rule" 2>/dev/null; then
+	echo 'Installing the udev rule for headset access (needs your password once).'
+	as_root install -Dm644 "$prefix/share/udev/70-monado-rifts.rules" "$rule"
+	as_root udevadm control --reload-rules
+	as_root udevadm trigger --subsystem-match=usb --attr-match=idVendor=2833 || true
+	as_root udevadm trigger --subsystem-match=hidraw || true
+fi
+
+systemctl --user daemon-reload
+systemctl --user enable --now "$service"
+echo 'rift-s-linux installed. Reconnect the Rift S, then start SteamVR from Steam.'
+if ldd "$prefix/bin/rifts-settings" 2>/dev/null | grep -q 'not found'; then
+	echo 'The Settings app needs WebKitGTK 4.1 and glibc 2.35 or newer'
+	echo '(Debian/Ubuntu: libwebkit2gtk-4.1-0, Fedora: webkit2gtk4.1, openSUSE: libwebkit2gtk-4_1-0).'
+fi
@@ -0,0 +1,61 @@
+#!/bin/sh
+# Assemble the universal tarball from a finished SDK build (see build.sh).
+#
+#   package.sh <work dir> <version>
+#
+# <work dir> holds src/{monado,basalt,...}, prefix/ (bundled libraries) and
+# stage/opt/rift-s-linux (the installed tree). Needs patchelf and xz on the host.
+set -eu
+
+work=$(cd "$1" && pwd)
+version=$2
+name=rift-s-linux-$version-x86_64
+out=$work/dist/$name
+files=$out/files
+src=$work/src
+licenses=$files/share/licenses/rift-s-linux
+
+rm -rf "$out"
+mkdir -p "$files"
+cp -a "$work/stage/opt/rift-s-linux/." "$files/"
+# The universal install never registers itself as the system OpenXR runtime.
+rm -rf "$files/share/openxr" "$files/lib/libopenxr_monado.so"
+
+# Bundled libraries: Basalt and its OpenCV/oneTBB. Everything else comes from the
+# host or, for the SteamVR driver, from the Steam Linux Runtime.
+for lib in libbasalt.so.2 libtbb.so.12 $(cd "$work/prefix/lib" && ls libopencv_*.so.412); do
+	cp -L "$work/prefix/lib/$lib" "$files/lib/$lib"
+done
+ln -s libbasalt.so.2 "$files/lib/libbasalt.so"
+
+# Relocatable lookup from each install location to the bundled lib/.
+set_rpath() {
+	for f in "$@"; do
+		if [ ! -L "$f" ] && file -b "$f" | grep -q ELF; then patchelf --set-rpath "$rpath" "$f"; fi
+	done
+}
+rpath='$ORIGIN/../lib' set_rpath "$files"/bin/*
+rpath='$ORIGIN' set_rpath "$files"/lib/*.so*
+rpath='$ORIGIN/../../../../lib' set_rpath "$files"/share/steamvr-monado/bin/linux64/*
+
+install -Dm644 "$src/monado/packaging/aur/rift-s-linux-git/70-monado-rifts.rules" \
+	"$files/share/udev/70-monado-rifts.rules"
+
+mkdir -p "$licenses"
+install -m644 "$src/monado/LICENSE" "$licenses/LICENSE"
+cp -a "$src/monado/LICENSES" "$licenses/Monado"
+(cd "$src/monado" && find src/external -type f \( -iname LICENSE -o -iname LICENSE.txt -o -iname COPYING \
+	-o -iname '*.license' \) -exec install -Dm644 {} "$licenses/{}" \;)
+for item in LICENSE thirdparty/basalt-headers/LICENSE thirdparty/basalt-headers/thirdparty/Sophus/LICENSE.txt \
+	thirdparty/basalt-headers/thirdparty/cereal/LICENSE thirdparty/CLI11/LICENSE thirdparty/magic_enum/LICENSE \
+	thirdparty/opengv/License.txt thirdparty/vit/LICENSE; do
+	install -Dm644 "$src/basalt/$item" "$licenses/Basalt/$item"
+done
+cp -a "$work/prefix/share/licenses/opencv4" "$licenses/OpenCV"
+install -m644 "$src"/opencv-*/LICENSE "$licenses/OpenCV/LICENSE"
+install -Dm644 "$src"/oneTBB-*/LICENSE.txt "$licenses/oneTBB/LICENSE.txt"
+install -Dm644 "$src"/fmt-*/LICENSE "$licenses/fmt/LICENSE"
+
+install -m755 "$src/monado/packaging/universal/install.sh" "$out/install.sh"
+tar -C "$work/dist" --sort=name --owner=0 --group=0 --numeric-owner -cJf "$work/dist/$name.tar.xz" "$name"
+echo "$work/dist/$name.tar.xz"
@@ -0,0 +1,6 @@
+#!/bin/sh
+# Run a command inside the Steam Runtime sniper SDK sysroot, with ~/src/universal/work at /work.
+here=$(dirname "$(readlink -f "$0")")
+exec bwrap --bind "$here/sysroot" / --dev /dev --proc /proc --tmpfs /tmp \
+  --bind "$here/work" /work --ro-bind /etc/resolv.conf /etc/resolv.conf \
+  --setenv HOME /work/home --setenv PATH /usr/local/bin:/usr/bin:/bin --chdir /work "$@"
@@ -0,0 +1,36 @@
+#!/bin/sh
+# Build the Settings app and add it to /work/stage. Runs in an Ubuntu 22.04 root
+# (webkit2gtk 4.1, glibc 2.35) after build.sh; needs cargo, pnpm and glslc.
+set -eu
+app=/work/src/monado/settings-app
+aur=/work/src/monado/packaging/aur/rift-s-linux-git
+dest=/work/stage/opt/rift-s-linux
+licenses=$dest/share/licenses/rift-s-linux
+meta=/work/build/settings
+mkdir -p "$meta"
+
+cd "$app"
+pnpm install --frozen-lockfile
+pnpm build
+# custom-protocol embeds the built frontend instead of using the dev server.
+cargo build --manifest-path src-tauri/Cargo.toml --release --locked --features custom-protocol -j${J:-8}
+cargo test --manifest-path src-tauri/Cargo.toml --release --locked --features custom-protocol -j${J:-8}
+cargo metadata --manifest-path src-tauri/Cargo.toml --locked --features custom-protocol --format-version 1 \
+	--filter-platform x86_64-unknown-linux-gnu > "$meta/rust.json"
+pnpm licenses list --prod --json > "$meta/js.json"
+
+install -Dm755 src-tauri/target/release/rifts-settings "$dest/bin/rifts-settings"
+install -Dm644 rifts-settings.desktop "$dest/share/applications/rifts-settings.desktop"
+sed -i -e "s|^Exec=.*|Exec=/opt/rift-s-linux/bin/rifts-settings|" \
+	-e "s|^Icon=.*|Icon=/opt/rift-s-linux/share/icons/hicolor/128x128/apps/rifts-settings.png|" \
+	"$dest/share/applications/rifts-settings.desktop"
+install -Dm644 src-tauri/icons/icon.png "$dest/share/icons/hicolor/128x128/apps/rifts-settings.png"
+install -Dm755 install-vrview-rule.sh "$dest/share/rifts-settings/install-vrview-rule.sh"
+install -Dm644 vrview.kwinrule "$dest/share/rifts-settings/vrview.kwinrule"
+
+install -Dm644 LICENSE "$licenses/Settings-MIT"
+install -Dm644 src/fonts/OFL.txt "$licenses/OpenSans-OFL"
+install -Dm644 src-tauri/native/OpenVR-LICENSE "$licenses/Settings-OpenVR"
+python3 "$aur/settings-licenses.py" "$meta/rust.json" "$meta/js.json" "$aur/settings-license-fallbacks.json" \
+	> "$licenses/Settings-third-party-notices.txt"
+echo settings-ok
@@ -8,12 +8,20 @@ import os
 from pathlib import Path
 import re
 import select
+import shutil
 import subprocess
 import sys
 import time

 DRIVER = Path('@CMAKE_INSTALL_FULL_DATADIR@/steamvr-monado')
 DESKTOP = Path('@CMAKE_INSTALL_FULL_BINDIR@/rifts-desktop')
+STEAMVR_APP = '250820'
+# Steam starts SteamVR inside the Steam Linux Runtime container, which cannot see the
+# host's /usr: a system-wide driver and its libraries would be missing. vrmonitor.sh
+# starts SteamVR on the host instead. The universal build installs into the home
+# directory, which the container shares, and needs no launch option.
+LAUNCH_SUFFIX = '/bin/vrmonitor.sh %command%'
+LAUNCH_PATH = ['UserLocalConfigStore', 'Software', 'Valve', 'Steam', 'apps', STEAMVR_APP]


 def read_registry(path):
@@ -66,46 +74,186 @@ def register(home, registry_path, uninstall=False):
    registry = read_registry(registry_path)
    tool, roots, libraries = find_runtime(home, registry)
    if tool is None:
-        return False, roots, libraries
+        return False, roots, libraries, None
+    runtime = tool.parents[2]
    drivers = registry.get('external_drivers') or []
    if uninstall:
        if str(DRIVER) in drivers:
            pathreg(tool, 'removedriver', str(DRIVER))
-        return True, roots, libraries
+        return True, roots, libraries, host_launch(roots, runtime, uninstall=True)
    if not (DRIVER / 'driver.vrdrivermanifest').is_file():
        raise RuntimeError('Installed Rift S driver manifest is missing.')
-    if str(DRIVER) in drivers:
-        return True, roots, libraries
-    # Bootstrap only missing native paths. Existing runtime/config/log paths remain intact.
-    if not registry.get('runtime'):
-        pathreg(tool, 'setthis')
-    root = roots[0] if roots else home / '.local/share/Steam'
-    if not registry.get('config'):
-        pathreg(tool, 'setconfig', str(root / 'config'))
-    if not registry.get('log'):
-        pathreg(tool, 'setlog', str(root / 'logs'))
-    pathreg(tool, 'adddriver', str(DRIVER))
-    return True, roots, libraries
+    if str(DRIVER) not in drivers:
+        # Bootstrap only missing native paths. Existing runtime/config/log paths remain intact.
+        if not registry.get('runtime'):
+            pathreg(tool, 'setthis')
+        root = roots[0] if roots else home / '.local/share/Steam'
+        if not registry.get('config'):
+            pathreg(tool, 'setconfig', str(root / 'config'))
+        if not registry.get('log'):
+            pathreg(tool, 'setlog', str(root / 'logs'))
+        pathreg(tool, 'adddriver', str(DRIVER))
+    # A home install drops the option a former system-wide install may have set.
+    return True, roots, libraries, host_launch(roots, runtime, uninstall=home in DRIVER.parents)


-def desktop_server_pid():
+def vdf_tokens(text):
+    """Return (kind, start, end, value) for the quoted strings and braces of Steam KeyValues text."""
+    tokens, i = [], 0
+    while i < len(text):
+        if text[i] == '"':
+            j, value = i + 1, []
+            while j < len(text) and text[j] != '"':
+                if text[j] == '\\' and j + 1 < len(text):
+                    j += 1
+                value.append(text[j])
+                j += 1
+            if j >= len(text):
+                raise ValueError('unterminated string')
+            tokens.append(('str', i, j + 1, ''.join(value)))
+            i = j + 1
+        elif text[i] in '{}':
+            tokens.append((text[i], i, i + 1, text[i]))
+            i += 1
+        elif text.startswith('//', i):
+            end = text.find('\n', i)
+            i = len(text) if end < 0 else end
+        else:
+            i += 1
+    return tokens
+
+
+def vdf_block(tokens, i=0, close=None):
+    """Parse items into {'items': [(key, value_token | block)], 'close': offset of the closing brace}."""
+    items = []
+    while i < len(tokens):
+        kind, start, _, key = tokens[i]
+        if kind == '}':
+            return {'items': items, 'close': start}, i + 1
+        if kind != 'str' or i + 1 >= len(tokens):
+            raise ValueError('expected key')
+        if tokens[i + 1][0] == 'str':
+            items.append((key, tokens[i + 1]))
+            i += 2
+        elif tokens[i + 1][0] == '{':
+            child, i = vdf_block(tokens, i + 2)
+            items.append((key, child))
+        else:
+            raise ValueError('expected value')
+    if close is None:
+        raise ValueError('unterminated block')
+    return {'items': items, 'close': close}, i
+
+
+def vdf_quote(value):
+    return '"' + value.replace('\\', '\\\\').replace('"', '\\"') + '"'
+
+
+def with_launch_options(text, value):
+    """Return text with SteamVR's LaunchOptions set to value (None removes ours), or None if the
+    user has custom options. Only the one line changes, so the rest of Steam's file stays byte-identical."""
+    block, _ = vdf_block(vdf_tokens(text), close=len(text))
+    for depth, key in enumerate(LAUNCH_PATH):
+        child = next((v for k, v in block['items'] if k.lower() == key.lower() and isinstance(v, dict)), None)
+        if child is None:
+            if value is None:
+                return text
+            # Insert the missing blocks before this block's closing brace, one level deeper.
+            at = text.rfind('\n', 0, block['close']) + 1
+            indent = '\t' * depth
+            lines = []
+            for level, missing in enumerate(LAUNCH_PATH[depth:]):
+                pad = indent + '\t' * level
+                lines += [f'{pad}{vdf_quote(missing)}\n', f'{pad}{{\n']
+            pad = indent + '\t' * (len(LAUNCH_PATH) - depth)
+            lines.append(f'{pad}"LaunchOptions"\t\t{vdf_quote(value)}\n')
+            lines += [f'{indent}{chr(9) * level}}}\n' for level in reversed(range(len(LAUNCH_PATH) - depth))]
+            return text[:at] + ''.join(lines) + text[at:]
+        block = child
+    current = next((v for k, v in block['items'] if k.lower() == 'launchoptions' and isinstance(v, tuple)), None)
+    ours = current is not None and current[3].replace('"', '').endswith(LAUNCH_SUFFIX)
+    if current is not None and current[3].strip() and not ours:
+        return None
+    if value is None:
+        if not ours:
+            return text
+        # Drop our whole line, keeping Steam's own entries.
+        start = text.rfind('\n', 0, current[1]) + 1
+        end = text.find('\n', current[2])
+        return text[:start] + text[end + 1 if end >= 0 else len(text):]
+    if current is not None:
+        return text[:current[1]] + vdf_quote(value) + text[current[2]:]
+    at = text.rfind('\n', 0, block['close']) + 1
+    pad = '\t' * len(LAUNCH_PATH)
+    return text[:at] + f'{pad}"LaunchOptions"\t\t{vdf_quote(value)}\n' + text[at:]
+
+
+def user_process(name):
    # Only comm and ownership, never process arguments or environments.
    for entry in Path('/proc').iterdir():
        if not entry.name.isdigit():
            continue
        try:
-            if entry.stat().st_uid == os.getuid() and (entry / 'comm').read_text().strip() == 'vrserver':
+            if entry.stat().st_uid == os.getuid() and (entry / 'comm').read_text().strip() == name:
                return int(entry.name)
        except (OSError, ProcessLookupError):
            pass
    return None


+def host_launch(roots, runtime, uninstall=False):
+    """Set (or on uninstall remove) the SteamVR launch option that keeps SteamVR on the host.
+    Steam rewrites localconfig.vdf on exit, so it is edited only while Steam is closed.
+    Returns a notice for the journal when the option cannot be applied yet."""
+    command = str(runtime) + LAUNCH_SUFFIX
+    if any(c.isspace() for c in str(runtime)):
+        command = vdf_quote(str(runtime) + LAUNCH_SUFFIX[:-len(' %command%')]) + ' %command%'
+    configs = sorted({path.resolve() for root in roots for path in root.glob('userdata/*/config/localconfig.vdf')})
+    if user_process('steam'):
+        if uninstall:
+            # A leftover vrmonitor.sh option still starts SteamVR normally.
+            return None
+        pending = []
+        for config in configs:
+            try:
+                text = config.read_text()
+                if with_launch_options(text, None if uninstall else command) not in (text, None):
+                    pending.append(config)
+            except (OSError, ValueError):
+                pass
+        if pending:
+            return 'Restart Steam once so SteamVR starts with the Rift S driver.'
+        return None
+    notice = None
+    for config in configs:
+        try:
+            text = config.read_text()
+            updated = with_launch_options(text, None if uninstall else command)
+        except (OSError, ValueError):
+            continue
+        if updated is None:
+            if not uninstall:
+                notice = f'SteamVR has custom launch options. Add {command} to start it with the Rift S driver.'
+            continue
+        if updated == text:
+            continue
+        temporary = config.with_name(config.name + '.rifts-tmp')
+        temporary.write_text(updated)
+        os.chmod(temporary, config.stat().st_mode & 0o777)
+        os.replace(temporary, config)
+    return notice
+
+
 def launch_desktop():
    # The client registers its manifest and preserves the user's autolaunch choice.
    # It also locks out duplicates when SteamVR has already started it.
-    subprocess.Popen([str(DESKTOP), '--autolaunch'], stdout=subprocess.DEVNULL,
-                     stderr=subprocess.DEVNULL, start_new_session=True)
+    command = [str(DESKTOP), '--autolaunch']
+    # Run it in its own unit: this service's memory limit only covers the watcher.
+    if shutil.which('systemd-run'):
+        subprocess.run(['systemd-run', '--user', '--quiet', '--collect', '--', *command],
+                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=20)
+    else:
+        subprocess.Popen(command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)


 class DirectoryEvents:
@@ -156,14 +304,18 @@ def main():
    events = DirectoryEvents()
    last_error = None
    last_desktop_server = None
+    last_notice = None
    with (state / 'registration.lock').open('w') as lock:
        while True:
            with_lock = False
            try:
                fcntl.flock(lock, fcntl.LOCK_EX)
                with_lock = True
-                done, roots, libraries = register(home, registry_path, args.action == 'uninstall')
+                done, roots, libraries, notice = register(home, registry_path, args.action == 'uninstall')
                last_error = None
+                if notice and notice != last_notice:
+                    print(notice, file=sys.stderr, flush=True)
+                last_notice = notice
            except (OSError, RuntimeError, subprocess.TimeoutExpired) as error:
                if args.action != 'watch':
                    raise SystemExit(str(error))
@@ -176,7 +328,7 @@ def main():
                if with_lock:
                    fcntl.flock(lock, fcntl.LOCK_UN)
            if done and DESKTOP.is_file():
-                server = desktop_server_pid()
+                server = user_process('vrserver')
                if args.action == 'uninstall':
                    if server:
                        subprocess.run([str(DESKTOP), '--unregister'], stdout=subprocess.DEVNULL,
@@ -191,7 +343,9 @@ def main():
                return
            directories = [config / 'openvr', home / '.local/share/Steam', home / '.steam']
            for root in roots:
-                directories.extend([root, root / 'steamapps'])
+                # Steam writes localconfig.vdf on exit; that is when the launch option can be set.
+                directories.extend([root, root / 'steamapps', root / 'userdata'])
+                directories.extend(root.glob('userdata/*/config'))
            for library in libraries:
                runtime = library / 'steamapps/common/SteamVR'
                directories.extend([library, library / 'steamapps', library / 'steamapps/common',
@@ -1,5 +1,8 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

+mod pairing;
+mod pairing_protocol;
+
 use chrono::{DateTime, Local};
 use serde::Serialize;
 use serde_json::{json, Value};
@@ -856,6 +859,10 @@ fn main() {
            Ok(())
        })
        .invoke_handler(tauri::generate_handler![
+            pairing::controller_pairing_status,
+            pairing::controller_pairing_start,
+            pairing::controller_pairing_select,
+            pairing::controller_pairing_cancel,
            snapshot,
            preview_layout,
            preview_status,
@@ -869,6 +876,7 @@ fn main() {
        .expect("Unable to start Rift S settings")
        .run(|_, event| {
            if matches!(event, tauri::RunEvent::Exit) {
+                pairing::shutdown();
                if let Ok(_lock) = VR.lock() {
                    unsafe { rifts_shutdown() };
                }
@@ -0,0 +1,328 @@
+// Copyright 2026, lbgos
+// SPDX-License-Identifier: BSL-1.0
+use crate::pairing_protocol::{Device, Radio, Transport, LEFT, RIGHT};
+use serde::Serialize;
+use std::{
+    fs::{self, File, OpenOptions},
+    os::fd::AsRawFd,
+    sync::{mpsc, Mutex},
+    thread::{self, JoinHandle},
+    time::{Duration, Instant},
+};
+
+#[derive(Clone, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Status {
+    stage: String,
+    message: String,
+    candidates: Vec<Candidate>,
+    hand: String,
+}
+
+#[derive(Clone, Serialize)]
+struct Candidate {
+    id: String,
+}
+
+enum Request {
+    Pair(u64),
+    Cancel,
+}
+
+#[derive(Default)]
+struct Session {
+    status: Status,
+    sender: Option<mpsc::Sender<Request>>,
+    worker: Option<JoinHandle<()>>,
+}
+static SESSION: Mutex<Session> = Mutex::new(Session {
+    status: Status {
+        stage: String::new(),
+        message: String::new(),
+        candidates: Vec::new(),
+        hand: String::new(),
+    },
+    sender: None,
+    worker: None,
+});
+
+fn publish(stage: &str, message: impl Into<String>, devices: &[Device]) {
+    if let Ok(mut session) = SESSION.lock() {
+        session.status = Status {
+            stage: stage.into(),
+            message: message.into(),
+            candidates: devices
+                .iter()
+                .map(|device| Candidate {
+                    id: format!("{:016x}", device.id),
+                })
+                .collect(),
+            hand: session.status.hand.clone(),
+        };
+    }
+}
+
+struct Hid(File);
+impl Hid {
+    fn open() -> Result<Self, String> {
+        if radio_in_use() {
+            return Err("Close SteamVR and Monado before pairing a controller.".into());
+        }
+        let mut paths = Vec::new();
+        for entry in fs::read_dir("/sys/class/hidraw")
+            .map_err(|e| e.to_string())?
+            .flatten()
+        {
+            let Ok(device) = fs::canonicalize(entry.path().join("device")) else {
+                continue;
+            };
+            let interface = device.ancestors().any(|path| {
+                fs::read_to_string(path.join("bInterfaceNumber")).is_ok_and(|s| s.trim() == "06")
+            });
+            let headset = device.ancestors().any(|path| {
+                fs::read_to_string(path.join("idVendor")).is_ok_and(|s| s.trim() == "2833")
+                    && fs::read_to_string(path.join("idProduct")).is_ok_and(|s| s.trim() == "0051")
+            });
+            if interface && headset {
+                paths.push(std::path::Path::new("/dev").join(entry.file_name()));
+            }
+        }
+        if paths.len() != 1 {
+            return Err(if paths.is_empty() {
+                "Rift S headset is not connected."
+            } else {
+                "Connect only one Rift S headset before pairing."
+            }
+            .into());
+        }
+        let file = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .open(&paths[0])
+            .map_err(|e| {
+                format!("Cannot open headset radio. Check Rift S device permissions: {e}")
+            })?;
+        unsafe extern "C" {
+            fn flock(fd: i32, operation: i32) -> i32;
+        }
+        if unsafe { flock(file.as_raw_fd(), 2 | 4) } < 0 {
+            return Err("Another pairing session owns the headset radio.".into());
+        }
+        Ok(Self(file))
+    }
+}
+
+impl Transport for Hid {
+    fn get(&mut self, report: u8) -> Result<Vec<u8>, String> {
+        let mut data = vec![0u8; 200];
+        data[0] = report;
+        let size = feature(&self.0, 0x07, &mut data)?;
+        data.truncate(size);
+        Ok(data)
+    }
+    fn set(&mut self, data: &[u8]) -> Result<(), String> {
+        // hidraw locks are advisory; the driver does not participate in them.
+        // Check again before every write if SteamVR was started during the scan.
+        if radio_in_use() {
+            return Err("A VR runtime started during pairing. Close it before retrying.".into());
+        }
+        let mut data = data.to_vec();
+        let size = feature(&self.0, 0x06, &mut data)?;
+        if size != data.len() {
+            return Err("Incomplete headset radio write. Pairing state may have changed.".into());
+        }
+        Ok(())
+    }
+}
+
+fn feature(file: &File, operation: u32, data: &mut [u8]) -> Result<usize, String> {
+    unsafe extern "C" {
+        fn ioctl(fd: i32, request: std::ffi::c_ulong, ...) -> i32;
+    }
+    // Linux HIDIOCGFEATURE/HIDIOCSFEATURE, both _IOC_READ | _IOC_WRITE.
+    let request = (3u32 << 30) | ((data.len() as u32) << 16) | (u32::from(b'H') << 8) | operation;
+    let result = unsafe {
+        ioctl(
+            file.as_raw_fd(),
+            request as std::ffi::c_ulong,
+            data.as_mut_ptr(),
+        )
+    };
+    if result < 0 {
+        Err(format!(
+            "Headset USB operation failed: {}",
+            std::io::Error::last_os_error()
+        ))
+    } else {
+        Ok(result as usize)
+    }
+}
+
+fn run(kind: u32, receiver: mpsc::Receiver<Request>) {
+    let result = (|| {
+        let mut radio = Radio(Hid::open()?);
+        let previous = radio.mode()?;
+        // Restore the original mode even when entering discovery only partly succeeds.
+        let outcome = (|| {
+            radio.set_mode(1)?;
+            let deadline = Instant::now() + Duration::from_secs(90);
+            loop {
+                let paired = radio.list(0x11)?;
+                let candidates: Vec<_> = radio
+                    .list(0x0c)?
+                    .into_iter()
+                    .filter(|device| {
+                        device.kind == kind
+                            && device.id != 0
+                            && !device.corrupt
+                            && !paired.iter().any(|old| old.id == device.id)
+                    })
+                    .collect();
+                publish(
+                    if candidates.is_empty() {
+                        "searching"
+                    } else {
+                        "ready"
+                    },
+                    if candidates.is_empty() {
+                        "Waiting for a controller."
+                    } else {
+                        "Select the controller to pair."
+                    },
+                    &candidates,
+                );
+                match receiver.recv_timeout(Duration::from_millis(500)) {
+                    Ok(Request::Cancel) | Err(mpsc::RecvTimeoutError::Disconnected) => {
+                        return Ok(false)
+                    }
+                    Ok(Request::Pair(id)) => {
+                        let selected = candidates
+                            .iter()
+                            .find(|device| device.id == id)
+                            .ok_or("Controller is no longer available. Scan again.")?;
+                        publish(
+                            "pairing",
+                            "Pairing controller. Keep Settings open and SteamVR closed.",
+                            &[],
+                        );
+                        radio.pair(selected).map_err(|error| format!("{error}. Pairing did not finish; the saved pairing list may have changed."))?;
+                        return Ok(true);
+                    }
+                    Err(mpsc::RecvTimeoutError::Timeout) => {}
+                }
+                if Instant::now() >= deadline {
+                    return Err("No controller selected within 90 seconds. Try again.".into());
+                }
+            }
+        })();
+        let restore = radio.set_mode(previous);
+        match (outcome, restore) {
+            (Ok(paired), Ok(())) => Ok(paired),
+            (Err(error), Ok(())) => Err(error),
+            (outcome, Err(error)) => Err(format!("{} Radio mode could not be restored: {error}. Reconnect the headset before starting SteamVR.",
+                match outcome { Ok(true) => "Controller was added to the pairing list.".into(), Ok(false) => "Scan cancelled.".into(), Err(error) => error })),
+        }
+    })();
+    match result {
+        Ok(true) => publish(
+            "complete",
+            "Controller added to the headset pairing list. You can start SteamVR.",
+            &[],
+        ),
+        Ok(false) => publish("cancelled", "Pairing scan cancelled.", &[]),
+        Err(error) => publish("failed", error, &[]),
+    }
+}
+
+#[tauri::command]
+pub fn controller_pairing_status() -> Result<Status, String> {
+    Ok(SESSION.lock().map_err(|e| e.to_string())?.status.clone())
+}
+
+#[tauri::command]
+pub fn controller_pairing_start(hand: String) -> Result<(), String> {
+    let kind = match hand.as_str() {
+        "left" => LEFT,
+        "right" => RIGHT,
+        _ => return Err("Invalid controller hand".into()),
+    };
+    if radio_in_use() {
+        return Err("Close SteamVR and Monado before pairing a controller.".into());
+    }
+    let mut session = SESSION.lock().map_err(|e| e.to_string())?;
+    if session
+        .worker
+        .as_ref()
+        .is_some_and(|worker| !worker.is_finished())
+    {
+        return Err("A controller pairing session is already running.".into());
+    }
+    let (sender, receiver) = mpsc::channel();
+    session.sender = Some(sender);
+    session.status = Status {
+        stage: "searching".into(),
+        message: "Opening headset radio.".into(),
+        candidates: vec![],
+        hand,
+    };
+    session.worker = Some(thread::spawn(move || run(kind, receiver)));
+    Ok(())
+}
+
+fn radio_in_use() -> bool {
+    ["vrserver", "monado-service", "monado-cli"]
+        .iter()
+        .any(|name| super::process_pid(name).is_some())
+}
+
+#[tauri::command]
+pub fn controller_pairing_select(id: String) -> Result<(), String> {
+    let mut session = SESSION.lock().map_err(|e| e.to_string())?;
+    if session.status.stage != "ready"
+        || !session
+            .status
+            .candidates
+            .iter()
+            .any(|candidate| candidate.id == id)
+    {
+        return Err("Controller is no longer available.".into());
+    }
+    let id = u64::from_str_radix(&id, 16).map_err(|e| e.to_string())?;
+    session
+        .sender
+        .as_ref()
+        .ok_or("No pairing session")?
+        .send(Request::Pair(id))
+        .map_err(|e| e.to_string())?;
+    session.status.stage = "pairing".into();
+    session.status.message = "Pairing controller.".into();
+    Ok(())
+}
+
+#[tauri::command]
+pub fn controller_pairing_cancel() -> Result<(), String> {
+    let session = SESSION.lock().map_err(|e| e.to_string())?;
+    if !["searching", "ready"].contains(&session.status.stage.as_str()) {
+        return Err("Wait for the pairing transaction to finish.".into());
+    }
+    session
+        .sender
+        .as_ref()
+        .ok_or("No pairing session")?
+        .send(Request::Cancel)
+        .map_err(|e| e.to_string())
+}
+
+pub fn shutdown() {
+    let worker = if let Ok(mut session) = SESSION.lock() {
+        if let Some(sender) = session.sender.take() {
+            let _ = sender.send(Request::Cancel);
+        }
+        session.worker.take()
+    } else {
+        None
+    };
+    if let Some(worker) = worker {
+        let _ = worker.join();
+    }
+}
@@ -0,0 +1,369 @@
+// Copyright 2026, lbgos
+// SPDX-License-Identifier: BSL-1.0
+//! Rift S wireless-host HID protocol. Lengths include the report ID.
+//! Pairing uses discovery mode, a temporary connection, then an app restart.
+//! This module has no firmware-update or unpair commands.
+
+use std::time::{Duration, Instant};
+
+pub const LEFT: u32 = 0x13001101;
+pub const RIGHT: u32 = 0x13011101;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Device {
+    pub id: u64,
+    pub kind: u32,
+    pub corrupt: bool,
+}
+
+pub trait Transport {
+    fn get(&mut self, report: u8) -> Result<Vec<u8>, String>;
+    fn set(&mut self, data: &[u8]) -> Result<(), String>;
+}
+
+pub fn devices(data: &[u8], report: u8) -> Result<Vec<Device>, String> {
+    let count_offset = if report == 0x11 { 1 } else { 2 };
+    if data.first() != Some(&report) || data.len() <= count_offset {
+        return Err("Invalid controller list report".into());
+    }
+    let count = usize::from(data[count_offset]);
+    let start = count_offset + 1;
+    if count > 4 || data.len() < start + count * 28 {
+        return Err("Truncated or oversized controller list".into());
+    }
+    data[start..start + count * 28]
+        .chunks_exact(28)
+        .map(|record| {
+            Ok(Device {
+                id: u64::from_le_bytes(record[..8].try_into().unwrap()),
+                kind: u32::from_le_bytes(record[8..12].try_into().unwrap()),
+                corrupt: record[27] & 1 != 0,
+            })
+        })
+        .collect()
+}
+
+pub struct Radio<T>(pub T);
+
+impl<T: Transport> Radio<T> {
+    fn idle(&mut self) -> Result<Vec<u8>, String> {
+        let deadline = Instant::now() + Duration::from_secs(5);
+        loop {
+            let data = self.0.get(0x0b)?;
+            if data.len() < 7 || data[0] != 0x0b {
+                return Err("Truncated wireless status".into());
+            }
+            if data[2] == 0 {
+                return Ok(data);
+            }
+            if Instant::now() >= deadline {
+                return Err("Headset radio is busy".into());
+            }
+            std::thread::sleep(Duration::from_millis(10));
+        }
+    }
+
+    pub fn command(&mut self, data: &[u8]) -> Result<Vec<u8>, String> {
+        let sequence = self.idle()?[1];
+        // Never retry a write: an ambiguous USB failure may have committed it.
+        self.0.set(data)?;
+        let deadline = Instant::now() + Duration::from_secs(5);
+        loop {
+            let reply = self.idle()?;
+            if reply[1] != sequence {
+                let status = u32::from_le_bytes(reply[3..7].try_into().unwrap());
+                return if status == 0 {
+                    Ok(reply)
+                } else {
+                    Err(format!(
+                        "Headset radio rejected command {:#04x}: {status:#x}",
+                        data[0]
+                    ))
+                };
+            }
+            if Instant::now() >= deadline {
+                return Err("Headset radio did not acknowledge the command".into());
+            }
+            std::thread::sleep(Duration::from_millis(10));
+        }
+    }
+
+    pub fn mode(&mut self) -> Result<u8, String> {
+        let data = self.0.get(0x0a)?;
+        match data.as_slice() {
+            [0x0a, mode @ 0..=2, ..] => Ok(*mode),
+            _ => Err("Invalid headset radio mode".into()),
+        }
+    }
+
+    pub fn set_mode(&mut self, mode: u8) -> Result<(), String> {
+        self.command(&[0x0a, mode])?;
+        if self.mode()? != mode {
+            return Err("Headset radio mode did not change".into());
+        }
+        Ok(())
+    }
+
+    pub fn list(&mut self, report: u8) -> Result<Vec<Device>, String> {
+        devices(&self.0.get(report)?, report)
+    }
+
+    pub fn pair(&mut self, selected: &Device) -> Result<(), String> {
+        if ![LEFT, RIGHT].contains(&selected.kind) || selected.id == 0 || selected.corrupt {
+            return Err("Controller type or app firmware is unsupported".into());
+        }
+        let whitelist = self.list(0x11)?;
+        if whitelist.iter().any(|device| device.id == selected.id) {
+            return Err("This controller is already paired".into());
+        }
+        if whitelist.len() == 4 {
+            return Err("Headset pairing list is full. No existing pairing was removed.".into());
+        }
+        if !self.list(0x0c)?.contains(selected) {
+            return Err(
+                "Controller stopped advertising. Hold its pairing buttons and try again.".into(),
+            );
+        }
+        let mut connect = vec![0x0d];
+        connect.extend(selected.id.to_le_bytes());
+        connect.extend(4000u16.to_le_bytes());
+        if let Err(error) = self.command(&connect) {
+            let cleanup = self.command(&[0x0e, 0]);
+            return Err(match cleanup {
+                Ok(_) => error,
+                Err(cleanup) => format!("{error}. Temporary connection cleanup failed: {cleanup}"),
+            });
+        }
+        let result: Result<(), String> = (|| {
+            let mut pair = vec![0x0f];
+            pair.extend(selected.kind.to_le_bytes());
+            self.command(&pair)?;
+            // Register 0x15 restarts the existing app, with no flash data.
+            let mut restart = vec![0u8; 61];
+            restart[0] = 0x13;
+            restart[1..9].copy_from_slice(&selected.id.to_le_bytes());
+            restart[9] = 0x15;
+            restart[11..13].copy_from_slice(&1000u16.to_le_bytes());
+            self.command(&restart)?;
+            Ok(())
+        })();
+        // End the temporary radio connection on success and failure.
+        // The disconnect report carries only the low byte of the target ID.
+        let disconnect = self.command(&[0x0e, selected.id as u8]);
+        match (result, disconnect) {
+            (Err(error), Err(cleanup)) => {
+                return Err(format!(
+                    "{error}. Temporary connection cleanup failed: {cleanup}"
+                ))
+            }
+            (Err(error), _) => return Err(error),
+            (_, Err(error)) => return Err(error),
+            _ => {}
+        }
+        let deadline = Instant::now() + Duration::from_secs(2);
+        loop {
+            let saved = self.list(0x11)?;
+            if whitelist.iter().any(|old| {
+                !saved
+                    .iter()
+                    .any(|device| device.id == old.id && device.kind == old.kind)
+            }) {
+                return Err("An existing controller is missing from the pairing list. Stop and check the headset.".into());
+            }
+            if saved
+                .iter()
+                .any(|device| device.id == selected.id && device.kind == selected.kind)
+            {
+                return Ok(());
+            }
+            if Instant::now() >= deadline {
+                return Err(
+                    "Pair command completed but the controller is absent from the pairing list"
+                        .into(),
+                );
+            }
+            std::thread::sleep(Duration::from_millis(100));
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::VecDeque;
+
+    #[test]
+    fn rejects_malformed_lists() {
+        for data in [vec![], vec![0x0c, 0], vec![0x0c, 0, 5], vec![0x0c, 0, 1]] {
+            assert!(devices(&data, 0x0c).is_err());
+        }
+        let mut data = vec![0x11, 1];
+        data.extend(42u64.to_le_bytes());
+        data.extend(LEFT.to_le_bytes());
+        data.extend([0; 16]);
+        assert_eq!(
+            devices(&data, 0x11).unwrap()[0],
+            Device {
+                id: 42,
+                kind: LEFT,
+                corrupt: false
+            }
+        );
+    }
+
+    struct Fake {
+        reads: VecDeque<Vec<u8>>,
+        writes: Vec<Vec<u8>>,
+        fail_write: bool,
+    }
+    impl Transport for Fake {
+        fn get(&mut self, report: u8) -> Result<Vec<u8>, String> {
+            let data = self.reads.pop_front().expect("unexpected read");
+            assert_eq!(data[0], report);
+            Ok(data)
+        }
+        fn set(&mut self, data: &[u8]) -> Result<(), String> {
+            self.writes.push(data.to_vec());
+            if self.fail_write {
+                Err("USB disconnected".into())
+            } else {
+                Ok(())
+            }
+        }
+    }
+
+    #[test]
+    fn command_requires_new_sequence_and_checks_result() {
+        let mut radio = Radio(Fake {
+            reads: [vec![11, 255, 0, 0, 0, 0, 0], vec![11, 0, 0, 3, 0, 0, 0]].into(),
+            writes: vec![],
+            fail_write: false,
+        });
+        assert!(radio.command(&[10, 1]).unwrap_err().contains("rejected"));
+        assert_eq!(radio.0.writes, [vec![10, 1]]);
+    }
+
+    #[test]
+    fn ambiguous_write_failure_is_never_retried() {
+        let mut radio = Radio(Fake {
+            reads: [vec![11, 1, 0, 0, 0, 0, 0]].into(),
+            writes: vec![],
+            fail_write: true,
+        });
+        assert!(radio.command(&[10, 1]).is_err());
+        assert_eq!(radio.0.writes.len(), 1);
+    }
+
+    fn list(report: u8, entries: &[Device]) -> Vec<u8> {
+        let mut data = if report == 0x11 {
+            vec![report, entries.len() as u8]
+        } else {
+            vec![report, 1, entries.len() as u8]
+        };
+        for device in entries {
+            data.extend(device.id.to_le_bytes());
+            data.extend(device.kind.to_le_bytes());
+            data.extend([0; 15]);
+            data.push(u8::from(device.corrupt));
+        }
+        data
+    }
+
+    #[test]
+    fn pair_preserves_existing_entries_and_verifies_new_identity() {
+        let old = Device {
+            id: 3,
+            kind: RIGHT,
+            corrupt: false,
+        };
+        let new = Device {
+            id: 0x12345678abcdef01,
+            kind: LEFT,
+            corrupt: false,
+        };
+        let mut reads = VecDeque::from([list(0x11, &[old.clone()]), list(0x0c, &[new.clone()])]);
+        for seq in 0..4 {
+            reads.push_back(vec![11, seq, 0, 0, 0, 0, 0]);
+            reads.push_back(vec![11, seq + 1, 0, 0, 0, 0, 0]);
+        }
+        reads.push_back(list(0x11, &[old, new.clone()]));
+        let mut radio = Radio(Fake {
+            reads,
+            writes: vec![],
+            fail_write: false,
+        });
+        radio.pair(&new).unwrap();
+        assert!(radio.0.reads.is_empty());
+        let writes = &radio.0.writes;
+        assert_eq!(
+            writes.iter().map(|data| data[0]).collect::<Vec<_>>(),
+            [0x0d, 0x0f, 0x13, 0x0e]
+        );
+        assert_eq!(&writes[0][1..9], &new.id.to_le_bytes());
+        assert_eq!(&writes[1][1..], &LEFT.to_le_bytes());
+        assert_eq!(writes[2].len(), 61);
+        assert_eq!(writes[2][9], 0x15);
+        assert_eq!(writes[2][10], 0);
+        assert_eq!(writes[3], [0x0e, new.id as u8]);
+    }
+
+    #[test]
+    fn full_whitelist_never_removes_existing_pairing() {
+        let entries: Vec<_> = (1..=4)
+            .map(|id| Device {
+                id,
+                kind: LEFT,
+                corrupt: false,
+            })
+            .collect();
+        let mut radio = Radio(Fake {
+            reads: [list(0x11, &entries)].into(),
+            writes: vec![],
+            fail_write: false,
+        });
+        assert!(radio
+            .pair(&Device {
+                id: 5,
+                kind: LEFT,
+                corrupt: false
+            })
+            .unwrap_err()
+            .contains("full"));
+        assert!(radio.0.writes.is_empty());
+    }
+
+    #[test]
+    fn rejected_pair_still_disconnects_without_restarting_controller() {
+        let new = Device {
+            id: 42,
+            kind: RIGHT,
+            corrupt: false,
+        };
+        let mut radio = Radio(Fake {
+            reads: [
+                list(0x11, &[]),
+                list(0x0c, &[new.clone()]),
+                vec![11, 0, 0, 0, 0, 0, 0],
+                vec![11, 1, 0, 0, 0, 0, 0],
+                vec![11, 1, 0, 0, 0, 0, 0],
+                vec![11, 2, 0, 1, 0, 0, 0],
+                vec![11, 2, 0, 0, 0, 0, 0],
+                vec![11, 3, 0, 0, 0, 0, 0],
+            ]
+            .into(),
+            writes: vec![],
+            fail_write: false,
+        });
+        assert!(radio.pair(&new).unwrap_err().contains("rejected"));
+        assert_eq!(
+            radio
+                .0
+                .writes
+                .iter()
+                .map(|data| data[0])
+                .collect::<Vec<_>>(),
+            [0x0d, 0x0f, 0x0e]
+        );
+        assert!(radio.0.reads.is_empty());
+    }
+}
@@ -79,6 +79,53 @@ function KeyValues({ rows }: { rows: [string, string][] }) {

 interface PreviewStatus { presented: number; width: number; height: number; error: string | null }

+interface PairingStatus { stage: string; message: string; candidates: { id: string }[]; hand?: 'left' | 'right' }
+function ControllerPairing() {
+  const [hand, setHand] = useState<'left' | 'right'>('left');
+  const [status, setStatus] = useState<PairingStatus>({ stage: '', message: '', candidates: [] });
+  const [error, setError] = useState('');
+  const [pollError, setPollError] = useState('');
+  const [pending, setPending] = useState(false);
+  const active = ['searching', 'ready', 'pairing'].includes(status.stage);
+  useEffect(() => {
+    let cancelled = false;
+    let timer: ReturnType<typeof setTimeout>;
+    async function poll() {
+      try {
+        const next = await invoke<PairingStatus>('controller_pairing_status');
+        if (!cancelled) {
+          setStatus(next);
+          if (['searching', 'ready', 'pairing'].includes(next.stage) && next.hand) setHand(next.hand);
+          setPollError('');
+        }
+      } catch (failure) { if (!cancelled) setPollError(String(failure)); }
+      if (!cancelled) timer = setTimeout(poll, 500);
+    }
+    void poll();
+    return () => { cancelled = true; clearTimeout(timer); };
+  }, []);
+  async function command(name: string, args?: Record<string, string>) {
+    setPending(true); setError('');
+    try {
+      await invoke(name, args);
+      setStatus(await invoke<PairingStatus>('controller_pairing_status'));
+    } catch (failure) { setError(String(failure)); }
+    finally { setPending(false); }
+  }
+  return <div className="sec pairing">
+    <h2>Pair controller</h2>
+    <p>Close SteamVR. Put a battery in the controller, then hold {hand === 'left' ? 'Menu + Y' : 'Oculus + B'} until its light flashes. Remove the old controller's battery when replacing it.</p>
+    <div className="pairing-controls">
+      <label>Hand <select aria-label="Controller hand" value={hand} disabled={active || pending} onChange={event => setHand(event.target.value as 'left' | 'right')}><option value="left">Left</option><option value="right">Right</option></select></label>
+      <button className="btn" disabled={active || pending} onClick={() => void command('controller_pairing_start', { hand })}>Find controller</button>
+      {active && status.stage !== 'pairing' && <button className="btn" disabled={pending} onClick={() => void command('controller_pairing_cancel')}>Cancel</button>}
+    </div>
+    {status.stage === 'ready' && status.candidates.map(candidate => <div className="pairing-candidate" key={candidate.id}><code>{candidate.id}</code><button className="btn sm" disabled={pending} onClick={() => void command('controller_pairing_select', { id: candidate.id })}>Pair {hand} controller</button></div>)}
+    <output className="fb" role="status">{error || pollError || status.message}</output>
+    <p className="pairing-note">Existing pairings stay saved. Firmware is never updated.</p>
+  </div>;
+}
+
 // The headset view is drawn natively: a Wayland subsurface owned by the Rust
 // side covers the preview box and receives GPU frames at the headset refresh
 // rate. This component only reports where the box is and shows status text
@@ -234,6 +281,7 @@ function App() {
              return <div key={name}><b>{name}</b><span>{device?.tracking ?? missing}</span>{i === 0 ? <span className="r">{device?.tracking ? 'Wired' : missing}</span> : <span className="bat">{battery != null && <i style={{ '--v': `${battery * 100}%` } as React.CSSProperties}/>} {format(battery == null ? null : battery * 100, '%')}</span>}</div>;
            })}
          </div></div>
+          <ControllerPairing/>
          <div className="sec"><h2>Cameras</h2><div className="t cam">
            <div className="h"><span>Position</span><span>State</span><span className="r">Rate</span></div>
            {['Front left', 'Front right', 'Top', 'Left', 'Right'].map((name, i) => <div key={name}><b>{name}</b><span>{i < 2 && data.cameraExport ? data.cameraActive ? 'Active' : 'No frames' : missing}</span><span className="r">{format(i < 2 ? data.cameraRate : null, ' Hz', 1)}</span></div>)}
@@ -27,6 +27,13 @@ main{flex:1;min-height:0;padding:1.5rem 2rem;display:flex}

 h2{margin:0 0 .75rem;font-size:.8125rem;font-weight:700;letter-spacing:.09em;text-transform:uppercase;line-height:2.25rem;display:flex;align-items:center;justify-content:space-between}
 .sec+.sec{margin-top:1.75rem}
+.pairing p{font-size:.8125rem;margin:0 0 .75rem}
+.pairing-controls,.pairing-candidate{display:flex;align-items:center;gap:.5rem;flex-wrap:wrap}
+.pairing-controls label{display:flex;align-items:center;gap:.5rem;font-size:.8125rem}
+.pairing select{background:#000;border:1px solid var(--line);padding:.375rem}
+.pairing-candidate{justify-content:space-between;margin-top:.5rem}
+.pairing .pairing-note{margin:.5rem 0 0;color:var(--mut)}
+#headset>.col:last-child{overflow-y:auto}

 /* controls */
 .btn{height:2.25rem;padding:0 1rem;border:0;border-radius:3px;background:var(--ctl);font-weight:600;font-size:.9rem;cursor:pointer;display:inline-flex;align-items:center;gap:.5rem;white-space:nowrap}
@@ -934,7 +934,15 @@ rift_s_tracker_push_slam_frames(struct rift_s_tracker *t,

 	timepoint_ns now_ns = os_monotonic_get_ns();
 	timepoint_ns frame_mono_ns = raw_frame_ts_to_mono_ts(t, frame_ts_ns);
-	if (frame_mono_ns < t->last_frame_time) {
+	if (t->last_frame_time - frame_mono_ns > (timepoint_ns)U_TIME_1S_IN_NS) {
+		/* A clock discontinuity, not jitter. At startup IMU samples are ignored until the
+		 * first frame is accepted, so the first frame's epoch offset is computed without
+		 * IMU time; when the IMU clock is a 2^32 us epoch ahead that frame maps far into
+		 * the past (or before 0). Rejecting it would keep last_frame_time at 0, keep IMU
+		 * ignored and the epoch uncorrected, so every later frame would be rejected too. */
+		RIFT_S_WARN("Camera clock discontinuity of %" PRId64 " ns; resyncing frame time",
+		            frame_mono_ns - t->last_frame_time);
+	} else if (frame_mono_ns < t->last_frame_time) {
 		RIFT_S_WARN("Camera frame time went backward by %" PRId64 " ns", frame_mono_ns - t->last_frame_time);
 		os_mutex_unlock(&t->mutex);
 		os_mutex_unlock(&t->slam_mutex);
@@ -42,14 +42,22 @@ bool rift_s_prepare_session_origin(const std::string &path)
    auto universes = cJSON_GetObjectItemCaseSensitive(document.get(), "universes");
    if (!cJSON_IsString(id) || std::strcmp(id->valuestring, "chaperone_info") || !cJSON_IsArray(universes))
        return false;
-    const cJSON *entry;
+    Json origin(cJSON_Parse("{\"universeID\":\"3\",\"seated\":{\"translation\":[0,0,0],\"yaw\":0},\"standing\":{\"translation\":[0,0,0],\"yaw\":0}}"), cJSON_Delete);
+    if (!origin) return false;
+    // Each session re-bases tracking, so offsets saved in universe 3 (for example by
+    // Quick Calibrate) would misplace the floor next time. Reset it to the plain origin.
+    int index = 0;
+    cJSON *entry;
    cJSON_ArrayForEach(entry, universes) {
        auto universe = cJSON_GetObjectItemCaseSensitive(entry, "universeID");
-        if (cJSON_IsString(universe) && std::strcmp(universe->valuestring, "3") == 0)
-            return true;
+        if (cJSON_IsString(universe) && std::strcmp(universe->valuestring, "3") == 0) {
+            if (cJSON_Compare(entry, origin.get(), true)) return true;
+            if (!cJSON_ReplaceItemInArray(universes, index, origin.get())) return false;
+            break;
+        }
+        ++index;
    }
-    Json origin(cJSON_Parse("{\"universeID\":\"3\",\"seated\":{\"translation\":[0,0,0],\"yaw\":0},\"standing\":{\"translation\":[0,0,0],\"yaw\":0}}"), cJSON_Delete);
-    if (!origin || !cJSON_AddItemToArray(universes, origin.get())) return false;
+    if (!entry && !cJSON_AddItemToArray(universes, origin.get())) return false;
    origin.release();
    std::unique_ptr<char, decltype(&cJSON_free)> bytes(cJSON_PrintUnformatted(document.get()), cJSON_free);
    if (!bytes) return false;
@@ -3,7 +3,7 @@
 #pragma once
 #include <string>

-// Add a parseable, unbounded session origin before publishing universe 3.
-// The saved universe and its geometry remain unchanged. Existing entries are preserved.
+// Write a parseable, unbounded session origin before publishing universe 3, replacing any
+// offsets left in universe 3 by an earlier session. Other universes remain unchanged.
 bool rift_s_prepare_session_origin(const std::string &path);
 bool rift_s_prepare_session_origin();
@@ -1550,6 +1550,10 @@ CDeviceDriver_Monado::Activate(vr::TrackedDeviceIndex_t unObjectId)
 	vr::VRProperties()->SetFloatProperty(m_ulPropertyContainer, vr::Prop_UserHeadToEyeDepthMeters_Float, 0.f);
 	vr::VRProperties()->SetFloatProperty(m_ulPropertyContainer, vr::Prop_DisplayFrequency_Float, m_flDisplayFrequency);
 	vr::VRProperties()->SetFloatProperty( m_ulPropertyContainer, vr::Prop_SecondsFromVsyncToPhotons_Float, m_flSecondsFromVsyncToPhotons);
+	// SteamVR's default steamvr/preferredRefreshRate is 90: the compositor asks for 90 Hz, finds only the Rift S
+	// 80 Hz mode and paces frames for the wrong rate (periodic timed-out frames). The Rift S has one mode.
+	if (strcmp(m_xdev->str, "Oculus Rift S") == 0)
+		vr::VRSettings()->SetFloat(vr::k_pch_SteamVR_Section, "preferredRefreshRate", m_flDisplayFrequency);

 	for (uint32_t i = 0; i < m_xdev->input_count; i++) {
 		if (m_xdev->inputs[i].name == XRT_INPUT_GENERIC_HEAD_DETECT)
@@ -86,12 +86,16 @@ public:
 	bool
 	publish(bool initialize_manual = false, bool saved_plane_trusted = true)
 	{
-		if (!saved_plane_trusted || !handle || !paths)
+		if (!handle || !paths)
 			return false;
 		vr::HmdMatrix34_t standing{}, setup{};
 		if (!transforms(standing, setup))
 			return false;
-		auto y = saved_floor(standing, setup);
+		// An untrusted saved plane belongs to another tracking session. Offer this
+		// session's nominal floor instead (raw Y=0, where the unanchored universe
+		// puts it): without any result the native step shows no floor to adjust.
+		const vr::HmdMatrix34_t session_origin{{{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}}};
+		auto y = saved_floor(saved_plane_trusted ? standing : session_origin, setup);
 		if (!y)
 			return false;
 		char message[128];
@@ -99,11 +103,12 @@ public:
 		bool sent = mailbox->Send(handle, "vrcompositor_systemlayer", message) == 0;
 		// The native manual step starts at tracking-origin Y=0. Seed it from the
 		// saved plane once; the first stick/laser adjustment selects Manual again.
-		if (sent && initialize_manual)
+		if (sent && initialize_manual && saved_plane_trusted)
 			sent = mailbox->Send(handle, "vrcompositor_systemlayer",
 			                     "{\"type\":\"reset_playspace_floorheight\",\"value_"
 			                     "source\":2}") == 0;
-		fprintf(stderr, "monado-roomsetup-floor: saved_floor_setup_y=%.6f sent=%d\n", *y, sent);
+		fprintf(stderr, "monado-roomsetup-floor: %s_floor_setup_y=%.6f sent=%d\n",
+		        saved_plane_trusted ? "saved" : "session", *y, sent);
 		return sent;
 	}
 };
@@ -3,6 +3,7 @@
 // Keep the pre-setup calibration if SteamVR's compositor dies during native drawing.
 #include "openvr.h"
 #include "ovrd_roomsetup_floor.hpp"
+#include "ovrd_spawn_close.hpp"
 #include "../../drivers/rift_s/rift_s_world_control.h"
 #include <cjson/cJSON.h>
 #include <chrono>
@@ -357,7 +358,7 @@ public:
 		posix_spawn_file_actions_adddup2(&actions, server_child, 3);
 		posix_spawn_file_actions_adddup2(&actions, monitor_child, 4);
 		posix_spawn_file_actions_adddup2(&actions, compositor_child, 5);
-		posix_spawn_file_actions_addclosefrom_np(&actions, 6);
+		roomsetup_spawn_close_from(&actions, 6);
 		int spawned = posix_spawn(&requester, executable, &actions, nullptr, arguments, environ);
 		posix_spawn_file_actions_destroy(&actions);
 		close(server_child); close(monitor_child); close(compositor_child);
@@ -370,6 +371,14 @@ public:
 };


+static bool same_transform(const vr::HmdMatrix34_t &a, const vr::HmdMatrix34_t &b)
+{
+	for (int row = 0; row < 3; ++row)
+		for (int column = 0; column < 4; ++column)
+			if (std::fabs(a.m[row][column] - b.m[row][column]) > 1e-4f) return false;
+	return true;
+}
+
 struct Snapshot
 {
 	std::string file;
@@ -387,11 +396,14 @@ static std::optional<Snapshot> snapshot(vr::IVRChaperoneSetup &setup, const fs::
 	return saved;
 }

-static bool restore(vr::IVRChaperoneSetup &setup, const fs::path &path, const Snapshot &saved)
+// The unbounded Rift S session universe has no perimeter, which CommitWorkingCopy rejects;
+// require_commit=false restores it from the file alone.
+static bool restore(vr::IVRChaperoneSetup &setup, const fs::path &path, const Snapshot &saved, bool require_commit = true)
 {
 	setup.RevertWorkingCopy();
-	if (!setup.ImportFromBufferToWorking(saved.exported.data(), 0) ||
-	    !setup.CommitWorkingCopy(vr::EChaperoneConfigFile_Live)) return false;
+	bool committed = setup.ImportFromBufferToWorking(saved.exported.data(), 0) &&
+	                 setup.CommitWorkingCopy(vr::EChaperoneConfigFile_Live);
+	if (!committed && require_commit) return false;
 	// Commit updates the server's live calibration. Restore the complete file too,
 	// including other universes and formatting that OpenVR's export does not retain.
 	auto temporary = path;
@@ -449,7 +461,10 @@ static void log_coordinates(vr::IVRSystem &system, vr::IVRChaperoneSetup &setup,

 int main(int argc, char **argv)
 {
-	if (argc == 2 && strcmp(argv[1], "--recover-display") == 0) return recover_display();
+	bool recover = argc == 2 && strcmp(argv[1], "--recover-display") == 0;
+	// Spawners pass descriptors 3 (guard) or 3-5 (display recovery); drop the rest.
+	roomsetup_close_inherited(recover ? 6 : 4);
+	if (recover) return recover_display();
 	if (argc != 4) return 1;
 	int parent = static_cast<int>(syscall(SYS_pidfd_open, std::atoi(argv[2]), 0));
 	int ready = std::atoi(argv[3]);
@@ -528,6 +543,21 @@ int main(int argc, char **argv)
 	auto next_notification_attempt = std::chrono::steady_clock::time_point{};
 	DisplayRecovery display_recovery(log_path);
 	auto next_display_check = std::chrono::steady_clock::time_point{};
+	// Quick Calibrate puts the floor where the headset is. Off-head the Rift S is in standby
+	// and holds its last head pose, so a calibration made then puts the floor at head height.
+	// Keep the last calibration made while worn and restore it over such a change.
+	const bool guard_standby_calibration = is_rift_s && setup_available;
+	std::optional<Snapshot> worn_calibration;
+	vr::HmdMatrix34_t worn_standing{};
+	uint64_t worn_universe = 0;
+	auto remember_calibration = [&] {
+		worn_calibration = snapshot(*setup, path);
+		worn_standing = system->GetRawZeroPoseToStandingAbsoluteTrackingPose();
+		worn_universe = system->GetUint64TrackedDeviceProperty(vr::k_unTrackedDeviceIndex_Hmd,
+		                                                       vr::Prop_CurrentUniverseId_Uint64);
+	};
+	if (guard_standby_calibration) remember_calibration();
+	bool calibration_changed = false;
 	while (running && !exited(parent)) {
 		// Test before consuming Accept's events, including a compositor that exits immediately before Accept.
 		bool recent_exit = std::chrono::steady_clock::now() <= exit_deadline;
@@ -599,9 +629,37 @@ int main(int argc, char **argv)
 			    event.eventType == vr::VREvent_RoomViewShown || event.eventType == vr::VREvent_RoomViewHidden ||
 			    event.eventType == vr::VREvent_DashboardActivated || event.eventType == vr::VREvent_DashboardDeactivated))
 				log_coordinates(*system, *setup, event.eventType, step);
+			if (guard_standby_calibration && (event.eventType == vr::VREvent_ChaperoneUniverseHasChanged ||
+			    event.eventType == vr::VREvent_ChaperoneDataHasChanged ||
+			    event.eventType == vr::VREvent_StandingZeroPoseReset))
+				calibration_changed = true;
 			if (event.eventType == vr::VREvent_Quit) { display_recovery.note_quit(); running = false; }
 		}
 		if (!running) break;
+		if (calibration_changed) {
+			calibration_changed = false;
+			bool standby = system->GetTrackedDeviceActivityLevel(vr::k_unTrackedDeviceIndex_Hmd) ==
+			               vr::k_EDeviceActivityLevel_Standby;
+			auto universe = system->GetUint64TrackedDeviceProperty(vr::k_unTrackedDeviceIndex_Hmd,
+			                                                       vr::Prop_CurrentUniverseId_Uint64);
+			if (standby && step == 0 && worn_calibration && universe == worn_universe &&
+			    !same_transform(system->GetRawZeroPoseToStandingAbsoluteTrackingPose(), worn_standing)) {
+				// SteamVR applies the reload asynchronously; its change event re-checks the result.
+				bool ok = restore(*setup, path, *worn_calibration, false);
+				fprintf(stderr, "monado-roomsetup-guard: standby calibration reverted=%s\n", ok ? "ok" : "FAILED");
+				if (notifications && overlay != vr::k_ulOverlayHandleInvalid) {
+					vr::VRNotificationId id;
+					notifications->CreateNotification(overlay, 0, vr::EVRNotificationType_Transient,
+					    ok ? "Quick Calibrate needs a tracked headset, and the Rift S stops tracking off your head. "
+					         "The previous floor and boundary were kept. Use Room Setup to set the floor."
+					       : "Quick Calibrate ran while the headset was off. Restoring the previous calibration failed. "
+					         "Run Room Setup before playing.",
+					    vr::EVRNotificationStyle_Application, nullptr, &id);
+				}
+			} else if (!standby || universe != worn_universe) {
+				remember_calibration();
+			}
+		}
 		if (world_setup && world_cancel_deadline != std::chrono::steady_clock::time_point{} &&
 		    std::chrono::steady_clock::now() >= world_cancel_deadline) {
 			world_command("cancel");
@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: BSL-1.0
 #pragma once
 #ifdef __linux__
+#include "ovrd_spawn_close.hpp"
+
 #include <dlfcn.h>
 #include <cerrno>
 #include <cstdio>
@@ -64,7 +66,7 @@ public:
 		posix_spawn_file_actions_adddup2(&actions, descriptors[1], child_acknowledgement);
 		// SteamVR also owns IPC descriptors without CLOEXEC. The guard must not
 		// retain those connections or shared buffers after a compositor exits.
-		posix_spawn_file_actions_addclosefrom_np(&actions, child_acknowledgement + 1);
+		roomsetup_spawn_close_from(&actions, child_acknowledgement + 1);
 		char destination[] = "3";
 		char *arguments[] = {executable.data(), library.data(), parent.data(), destination, nullptr};
 		int error = posix_spawn(&pid, executable.c_str(), &actions, nullptr, arguments, environ);
@@ -0,0 +1,39 @@
+// Copyright 2026, lbgos
+// SPDX-License-Identifier: BSL-1.0
+/*!
+ * @file
+ * @brief Keep SteamVR's inherited descriptors out of spawned guard processes.
+ *
+ * The spawner calls roomsetup_spawn_close_from() on its spawn actions. glibc before
+ * 2.34 (the Steam Runtime) has no close-from spawn action, so the guard also calls
+ * roomsetup_close_inherited() first thing in main().
+ */
+#pragma once
+
+#include <spawn.h>
+#include <sys/resource.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+inline void
+roomsetup_spawn_close_from(posix_spawn_file_actions_t *actions, int first)
+{
+#if defined(__GLIBC__) && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 34))
+	posix_spawn_file_actions_addclosefrom_np(actions, first);
+#else
+	(void)actions;
+	(void)first;
+#endif
+}
+
+inline void
+roomsetup_close_inherited(int first)
+{
+#ifdef SYS_close_range
+	if (syscall(SYS_close_range, first, ~0U, 0) == 0) return;
+#endif
+	// Kernels before 5.9.
+	rlimit limit{};
+	int last = getrlimit(RLIMIT_NOFILE, &limit) == 0 && limit.rlim_cur != RLIM_INFINITY ? int(limit.rlim_cur) : 65536;
+	for (int descriptor = first; descriptor < last; ++descriptor) close(descriptor);
+}
@@ -257,3 +257,12 @@ if(XRT_BUILD_DRIVER_RIFT_S AND XRT_MODULE_CONSTELLATION_TRACKING)
 	target_link_libraries(tests_rift_s_controller_capture PRIVATE xrt-external-catch2 drv_rift_s aux_math aux_tracking aux_util_sink)
 	add_test(NAME tests_rift_s_controller_capture COMMAND tests_rift_s_controller_capture)
 endif()
+
+# rifts-setup edits Steam's own config; cover its KeyValues editing.
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+	find_package(Python3 COMPONENTS Interpreter)
+	if(Python3_Interpreter_FOUND)
+		add_test(NAME rifts_setup COMMAND Python3::Interpreter -I ${CMAKE_CURRENT_SOURCE_DIR}/rifts_setup_test.py
+		                                  ${PROJECT_BINARY_DIR}/rifts-setup)
+	endif()
+endif()
@@ -0,0 +1,68 @@
+# Copyright 2026, lbgos
+# SPDX-License-Identifier: BSL-1.0
+"""Checks how rifts-setup edits SteamVR's launch option in Steam's localconfig.vdf.
+
+Usage: rifts_setup_test.py <configured rifts-setup script>
+"""
+import importlib.machinery
+import importlib.util
+import sys
+import unittest
+
+loader = importlib.machinery.SourceFileLoader('rifts_setup', sys.argv.pop(1))
+setup = importlib.util.module_from_spec(importlib.util.spec_from_loader(loader.name, loader))
+loader.exec_module(setup)
+
+OURS = '/home/u/.local/share/Steam/steamapps/common/SteamVR/bin/vrmonitor.sh %command%'
+
+
+def config(app_lines):
+    body = ''.join('\t\t\t\t\t\t' + line + '\n' for line in app_lines)
+    return ('"UserLocalConfigStore"\n{\n\t"Software"\n\t{\n\t\t"Valve"\n\t\t{\n\t\t\t"Steam"\n\t\t\t{\n'
+            '\t\t\t\t"apps"\n\t\t\t\t{\n\t\t\t\t\t"250820"\n\t\t\t\t\t{\n' + body +
+            '\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n')
+
+
+def launch_options(text):
+    block, _ = setup.vdf_block(setup.vdf_tokens(text), close=len(text))
+    for key in setup.LAUNCH_PATH:
+        block = next(v for k, v in block['items'] if k.lower() == key.lower())
+    return next((v[3] for k, v in block['items'] if k == 'LaunchOptions'), None)
+
+
+class LaunchOptions(unittest.TestCase):
+    def test_adds_line_and_keeps_the_rest(self):
+        before = config(['"LastPlayed"\t\t"1"'])
+        after = setup.with_launch_options(before, OURS)
+        self.assertEqual(after, config(['"LastPlayed"\t\t"1"', '"LaunchOptions"\t\t"' + OURS + '"']))
+
+    def test_fills_empty_option(self):
+        after = setup.with_launch_options(config(['"LaunchOptions"\t\t""']), OURS)
+        self.assertEqual(after, config(['"LaunchOptions"\t\t"' + OURS + '"']))
+
+    def test_keeps_custom_option(self):
+        self.assertIsNone(setup.with_launch_options(config(['"LaunchOptions"\t\t"gamemoderun %command%"']), OURS))
+
+    def test_updates_our_option_after_steamvr_moves(self):
+        old = config(['"LaunchOptions"\t\t"/old/SteamVR/bin/vrmonitor.sh %command%"'])
+        self.assertEqual(launch_options(setup.with_launch_options(old, OURS)), OURS)
+
+    def test_uninstall_removes_only_our_line(self):
+        installed = config(['"LaunchOptions"\t\t"' + OURS + '"', '"LastPlayed"\t\t"1"'])
+        self.assertEqual(setup.with_launch_options(installed, None), config(['"LastPlayed"\t\t"1"']))
+        custom = config(['"LaunchOptions"\t\t"gamemoderun %command%"'])
+        self.assertIsNone(setup.with_launch_options(custom, None))
+
+    def test_creates_missing_app_block(self):
+        before = config([]).replace('\t\t\t\t\t"250820"\n\t\t\t\t\t{\n\t\t\t\t\t}\n', '')
+        after = setup.with_launch_options(before, OURS)
+        self.assertEqual(launch_options(after), OURS)
+        self.assertEqual(after, config(['"LaunchOptions"\t\t"' + OURS + '"']))
+
+    def test_quoted_values_round_trip(self):
+        spaced = '"/my games/SteamVR/bin/vrmonitor.sh" %command%'
+        self.assertEqual(launch_options(setup.with_launch_options(config([]), spaced)), spaced)
+
+
+if __name__ == '__main__':
+    unittest.main()
@@ -108,7 +108,7 @@ TEST_CASE("Setup RGB projection keeps eye rays independent of surface depth")
 	}
 }

-TEST_CASE("Saved floor sends a numeric detection and only seeds manual entry once")
+TEST_CASE("Floor detection uses the saved plane only when trusted and seeds manual entry from it")
 {
 	struct Messages : roomsetup::Mailbox
 	{
@@ -153,26 +153,29 @@ TEST_CASE("Saved floor sends a numeric detection and only seeds manual entry onc
 		}
 	} paths;
 	roomsetup::SavedFloor floor{&messages, &paths};
-	// An unlocalized room must not inject either the old plane or a manual-floor reset.
-	CHECK_FALSE(floor.publish(true, false));
-	CHECK_FALSE(floor.publish(false, false));
-	CHECK(messages.sent.empty());
-	REQUIRE(floor.publish());
+	auto position = [&](size_t index) {
+		auto *result = cJSON_Parse(messages.sent.at(index).c_str());
+		REQUIRE(result);
+		CHECK(cJSON_IsNumber(cJSON_GetObjectItem(result, "pos")));
+		CHECK(cJSON_GetObjectItem(result, "position") == nullptr);
+		double value = cJSON_GetNumberValue(cJSON_GetObjectItem(result, "pos"));
+		cJSON_Delete(result);
+		return value;
+	};
+	// An unlocalized room must not inject the old plane or a manual-floor reset,
+	// but first setup still needs the session's nominal floor at raw Y=0.
+	REQUIRE(floor.publish(true, false));
 	REQUIRE(messages.sent.size() == 1);
-	auto *result = cJSON_Parse(messages.sent[0].c_str());
-	REQUIRE(result);
-	CHECK(cJSON_IsNumber(cJSON_GetObjectItem(result, "pos")));
-	CHECK(cJSON_GetNumberValue(cJSON_GetObjectItem(result, "pos")) == Catch::Approx(.9));
-	CHECK(cJSON_GetObjectItem(result, "position") == nullptr);
-	cJSON_Delete(result);
+	CHECK(position(0) == Catch::Approx(.7));
+	REQUIRE(floor.publish());
+	REQUIRE(messages.sent.size() == 2);
+	CHECK(position(1) == Catch::Approx(.9));
 	REQUIRE(floor.publish(true));
-	REQUIRE(messages.sent.size() == 3);
-	auto *reset = cJSON_Parse(messages.sent[2].c_str());
+	REQUIRE(messages.sent.size() == 4);
+	auto *reset = cJSON_Parse(messages.sent[3].c_str());
 	REQUIRE(reset);
 	CHECK(cJSON_GetNumberValue(cJSON_GetObjectItem(reset, "value_source")) == 2);
 	cJSON_Delete(reset);
-	CHECK_FALSE(floor.publish(true, false));
-	CHECK(messages.sent.size() == 3);
 }

 TEST_CASE("Boundary warning retries failed delivery and removal")
@@ -225,6 +228,13 @@ TEST_CASE("Native session origin has no geometry and preserves the saved room")
    CHECK(cJSON_GetObjectItemCaseSensitive(origin, "collision_bounds") == nullptr);
    REQUIRE(rift_s_prepare_session_origin(fixture.path.string()));
    CHECK(read_file(fixture.path) == bytes);
+    // A Quick Calibrate offset from an earlier session must not survive the re-based origin.
+    fixture.write(R"({"jsonid":"chaperone_info","version":5,"universes":[)" + saved +
+                  R"(,{"universeID":"3","standing":{"translation":[0,-1.6,0],"yaw":0.3}}]})");
+    REQUIRE(rift_s_prepare_session_origin(fixture.path.string()));
+    auto calibrated = read_file(fixture.path);
+    CHECK(calibrated.find(saved) != std::string::npos);
+    CHECK(calibrated == bytes);
    fixture.write("broken json");
    CHECK_FALSE(rift_s_prepare_session_origin(fixture.path.string()));
    CHECK(read_file(fixture.path) == "broken json");
Author	SHA1	Message	Date
lbgos	5caba039b7	Arch packages: release r30	2026-10-17 14:47:43 +03:00
lbgos	b23b5e24d0	README: universal install, controller pairing; install.sh WebKitGTK hint	2026-10-17 14:30:54 +03:00
lbgos	92d892f7ec	Add Rift S controller pairing to Settings	2026-10-17 14:25:21 +03:00
lbgos	2036af9170	Universal x86_64 build for non-Arch distributions Build the driver in the Steam Runtime sniper SDK and install it under ~/.local/share, which SteamVR sees inside its container, so no launch option is needed. glibc 2.31 and old libwayland compatibility, a relocatable overlay manifest, and the overlay in its own systemd unit.	2026-10-17 14:25:21 +03:00
lbgos	edaa507b59	Arch packages: release r29	2026-10-16 22:22:55 +03:00
lbgos	41e1aabe06	Rift S: keep Quick Calibrate from putting the floor at head height Quick Calibrate places the floor where the headset is, but off-head the Rift S is in standby and holds its last head pose, so the floor ended up at head height (#5). The Room Setup guard now keeps the calibration made while the headset was in use. If the standing origin changes in the same universe while the headset is in standby, the guard restores that calibration and explains that Room Setup sets the floor. The unbounded session universe cannot be committed through IVRChaperoneSetup, so this restore reloads the saved file. Each session also re-bases tracking, so offsets saved in universe 3 sent the floor to the wrong height in later sessions. The session origin is now reset to the plain origin at startup. The saved room (universe 2) is unchanged. Fixes #5	2026-10-16 21:23:22 +03:00
lbgos	68c8b14a36	roomsetup: give first-time setup a floor to adjust Full Room Setup (step 7) resets the floor to pending detection and waits for floor_detection_result. The guard only published the saved plane, and on a first setup it does not trust that plane, so no result ever arrived: the step showed no floor, and pulling the trigger off the panel just hid the dashboard, which cancels setup (#4). When the saved plane is untrusted, publish this session's nominal floor (raw Y=0, the floor the unanchored universe already uses). The user then adjusts it as usual. The old plane and the manual-floor reset are still never sent from an untrusted session. Refs #4	2026-10-16 21:23:22 +03:00
lbgos	0863f9eb27	rifts-setup: keep SteamVR on the host so the driver loads Steam starts SteamVR 2.17 inside the Steam Linux Runtime (sniper) container, which only sees the host's /usr under /run/host. vrserver then skips /usr/share/steamvr-monado as "not a directory" and reports HmdNotFound (#3). The registration service now sets SteamVR's launch option to vrmonitor.sh %command%, which starts SteamVR on the host. Steam rewrites localconfig.vdf on exit, so the option is written only while Steam is closed, and the service logs a restart hint until then. Custom launch options are left alone. Uninstall removes only this option. Fixes #3	2026-10-16 21:05:22 +03:00
Ryan FordandClaude Opus 5.5	b7826d277f	steamvr_drv: set SteamVR's preferred refresh rate to the Rift S rate SteamVR's default steamvr/preferredRefreshRate is 90. On start the compositor logs "Trying to match desired rate of 90.000000Hz", only finds the 1440x2560@80 mode, sets Prop_DisplayFrequency_Float to 90 and paces frames for 90 Hz. UpdateDisplayFrequency() then puts the property back to 80, but the frames are still paced wrong. A light app (SteamVR Home at ~5 ms CPU/GPU) still dropped ~9% of frames with ~1 timed-out frame per second; with no reprojection on Linux each dropped frame is a visible hitch. Write the device's display frequency to steamvr/preferredRefreshRate when the Rift S activates, before the compositor starts. The compositor then requests 80 Hz and the frequency override no longer fires. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-16 20:54:32 +03:00
Ryan FordandClaude Opus 5.5	e9a098e313	rift_s: resync camera frame time after a clock discontinuity IMU samples are ignored until the first SLAM frame is accepted, so the first frame's epoch offset is computed against an IMU timestamp of 0. When the extended IMU clock is a 2^32 us epoch ahead of the camera clock, that frame maps to a negative monotonic time and is rejected as "went backward". last_frame_time then stays 0, IMU stays ignored, the epoch offset is never corrected, and every following frame is rejected too: no head tracking, an empty grey Room View in Room Setup. Seen on 8 of 8 starts on one headset, e.g.: frame_ts=1625067443000 imu_ts=0 hw2mono=-3395444712931 -> mono=-1770377269931 (now=2524604154978) with the IMU clock at 5920 s vs the camera at 1625 s once IMU ran. Treat a backward step of more than a second as a discontinuity and accept the frame. It is not fresh, so it is not submitted to SLAM, but it ungates IMU; the next frame gets the correct epoch offset and maps to ~now. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-16 20:54:32 +03:00
lbgos	ad1553f855	Arch packages: prebuilt release package and PKGBUILDs	2026-10-14 15:43:18 +03:00