diff --git a/docs/README/FT_POINTER.md b/docs/README/FT_POINTER.md
new file mode 100644
index 0000000..0951d0d
--- /dev/null
+++ b/docs/README/FT_POINTER.md
@@ -0,0 +1,23 @@
+# FT_POINTER
+
+Script / module: `pointer/helper/ft-pointer.cpp` (user service via `pointer/helper/run.sh`)
+
+## Purpose
+
+3D pointer helper for SteamVR overlays: laser hit-testing, drag lock, SteamVR Settings workaround, `POINTER_IGNORE`, and placement helpers used by layout.
+
+## Floating panels
+
+`FramePanel()` treats `frametop.screen.N`, `frametop.float.N`, and `frametop.float.N.sub.K` as desktop panels the laser can retarget across while a press is held and the pressed overlay has not moved. Left release sends `up` to `@ft_screens` as a backstop for the catcher. `POINTER_IGNORE` still cannot drop any `frametop.*` key (Phase 2 hard guard).
+
+## Related
+
+[FT_FLOATD.md](FT_FLOATD.md), [INPUT-RELAY.md](INPUT-RELAY.md), `docs/floating-windows.md`.
+
+## Tests
+
+```
+python3 test/test_pointer_ignore.py
+python3 test/test_float_phase3.py
+bash test/test_steamvr_client_init.sh
+```
diff --git a/docs/README/INPUT-RELAY.md b/docs/README/INPUT-RELAY.md
index ffeacc2..d1918f6 100644
--- a/docs/README/INPUT-RELAY.md
+++ b/docs/README/INPUT-RELAY.md
@@ -28,11 +28,16 @@ The desktop's input method ([FT_TEXTINPUT.md](FT_TEXTINPUT.md)) sends `textfield
 
 `keyboard_toggle` ("Open/close keyboard") is a new action, before `key` in `ACTIONS`, for mouse buttons and Frame controller buttons. Both paths go through `do_action`, which sends `vrkeyboard toggle` on a press (unless the mode is `never`) and hands every other action to `Pointer.action`. A keyboard made by a program through uinput (frame-voice's, say) doesn't count as "connected": `probe` marks a node `uinput` when its sysfs path is under `/sys/devices/virtual/input/`, `Node.describe()` reports it, and the `no_keyboard` check skips it (as it does keyboards set to Ignore or Pointer).
 
+## Floating windows
+
+`float_toggle` and `dock_all` send `float pointer` / `dock all` to ft-floatd on `@frametop_float` (they work even when pointer mode is off). A rules file without `key_bindings` gets `DEFAULT_KEY_BINDINGS`: Meta+Shift+F (`42+125+33`) → `float_toggle`. A file that defines its own `key_bindings` object, even `{}`, does not get that default. Combinations are taken on passthrough keyboards before the key is typed; Meta is swallowed on the desktop for the combo so Plasma's launcher does not open. This fork does not ship gaze key bindings.
+
 ## Tests
 
 ```
 python3 test/test_input_relay_control.py   # needs Linux/WSL abstract AF_UNIX
 python3 test/test_vr_keyboard_relay.py     # modes, persist, uinput detection, keyboard_toggle
+python3 test/test_float_phase3.py          # float wiring, Meta+Shift+F, crop math
 bash test/test_boot_safety.sh
 bash test/test_steamvr_client_init.sh
 ```
diff --git a/docs/README/OVERVIEW.md b/docs/README/OVERVIEW.md
index 2455429..414377c 100644
--- a/docs/README/OVERVIEW.md
+++ b/docs/README/OVERVIEW.md
@@ -16,7 +16,12 @@ Frametop tools and docs for the Steam Frame nested desktop.
 | `layout/ft_layout.py` | [FT_LAYOUT.md](FT_LAYOUT.md) |
 | `session/ft-launch.py` | [FT-LAUNCH.md](FT-LAUNCH.md) |
 | `layout/ft_desktop.py` | [FT_DESKTOP.md](FT_DESKTOP.md) |
+| `input/input-relay.py` | [INPUT-RELAY.md](INPUT-RELAY.md) |
 | `input/ft-textinput` | [FT_TEXTINPUT.md](FT_TEXTINPUT.md) |
+| `pointer/helper/ft-pointer.cpp` | [FT_POINTER.md](FT_POINTER.md) |
 | `screens/keyboard.cpp` | [SCREENS_KEYBOARD.md](SCREENS_KEYBOARD.md) |
+| `screens/test/headless.sh` | [SCREENS_TEST_HEADLESS.md](SCREENS_TEST_HEADLESS.md) |
+| `float/ft_floatd.py` | [FT_FLOATD.md](FT_FLOATD.md) |
+| `float/ft_apps.py` | [FT_APPS.md](FT_APPS.md) |
 
-Layout / Spatial Instruments CLI and profile format live in `docs/reference.md` (and `docs/design.md`). `ft-layout apply` still pushes visibility, KWin scales, and instruments when the HMD pose is not ready yet (see [FT_LAYOUT.md](FT_LAYOUT.md)). Display Settings → **Background** uses `frame-background`; recover-vr also clears a broken empty `steamvr-pending.path` that can black-screen SteamVR after the boot logo.
+Layout / Spatial Instruments CLI and profile format live in `docs/reference.md` (and `docs/design.md`). `ft-layout apply` still pushes visibility, KWin scales, and instruments when the HMD pose is not ready yet (see [FT_LAYOUT.md](FT_LAYOUT.md)). Display Settings → **Background** uses `frame-background`; recover-vr also clears a broken empty `steamvr-pending.path` that can black-screen SteamVR after the boot logo. Launcher Configure writes/removes apps in-process in Display Settings (then host-syncs VR) so remove and the “application not available” warning stay reliable inside distrobox — see [FT_DISPLAY_SETTINGS.md](FT_DISPLAY_SETTINGS.md). SteamVR overlay clients (ft-pointer, ft-screens, ft-gaze) probe as Background before Overlay and use `Requisite=steamvr.service` so they cannot bootstrap a rogue vrserver; see `docs/design.md`. Floating windows use spare KWin outputs (`FLOAT_SLOTS`), `ft-floatd`, and `frametop.float.N` panels — see [FT_FLOATD.md](FT_FLOATD.md) and `docs/floating-windows.md`.
diff --git a/input-settings/ft_input_settings.py b/input-settings/ft_input_settings.py
index 676dfa5..9108f62 100644
--- a/input-settings/ft_input_settings.py
+++ b/input-settings/ft_input_settings.py
@@ -63,6 +63,7 @@ ACTION_LABELS = {
     "sens_up": "Faster pointer",
     "sens_down": "Slower pointer", "layout_reset": "Reset desktop screen layout",
     "screens_toggle": "Hide/show desktop screens", "keyboard_toggle": "Open/close keyboard",
+    "float_toggle": "Float/dock window", "dock_all": "Dock all floating windows",
     "profile_slot_1": "Apply profile slot 1", "profile_slot_2": "Apply profile slot 2",
     "profile_slot_3": "Apply profile slot 3", "profile_slot_4": "Apply profile slot 4",
     "profile_slot_5": "Apply profile slot 5", "profile_slot_6": "Apply profile slot 6",
diff --git a/input/input-relay.py b/input/input-relay.py
index 839bc62..cff0153 100755
--- a/input/input-relay.py
+++ b/input/input-relay.py
@@ -23,7 +23,9 @@ pointer_toggle, follow_toggle = head follow on or off, gaze_toggle = gaze mode o
 (the pointer goes where you look; see pointer/helper/ft-pointer.cpp), sens_up, sens_down,
 layout_reset = put the desktop screens back in their saved layout, screens_toggle = hide or show
 the desktop screens, profile_slot_1..6 / profile_next / profile_previous = apply named profile
-slots via ft-layout, keyboard_toggle = open or close Frametop's keyboard, key = pass through as a
+slots via ft-layout, keyboard_toggle = open or close Frametop's keyboard, float_toggle = float the
+desktop window under the pointer (else the active one) in VR or dock it if it floats, dock_all =
+put every floating window back (both go to ft-floatd on @frametop_float), key = pass through as a
 key, none).
 
 Frame controller buttons can be mapped too ("controller_buttons": {"right/a": action} in the
@@ -173,7 +175,8 @@ RULES_PATH = os.path.expanduser("~/.config/frametop-input.json")
 ACTIONS = ("left", "right", "middle", "back", "scroll_up", "scroll_down", "dashboard", "recenter",
            "pointer_toggle", "follow_toggle", "gaze_toggle", "sens_up", "sens_down", "layout_reset", "screens_toggle",
            "profile_slot_1", "profile_slot_2", "profile_slot_3", "profile_slot_4", "profile_slot_5",
-           "profile_slot_6", "profile_next", "profile_previous", "keyboard_toggle", "key", "none")
+           "profile_slot_6", "profile_next", "profile_previous", "keyboard_toggle", "float_toggle", "dock_all",
+           "key", "none")
 VR_KEYBOARD_MODES = ("always", "no_keyboard", "button", "never")  # when Frametop's keyboard opens
 HELPER = "\0ft_pointer_helper"
 # Frame controller buttons the pointer helper can read (pointer/helper/vrbuttons.h).
@@ -182,6 +185,24 @@ VR_BUTTONS = ("left/view", "left/dpad_up", "left/dpad_down", "left/dpad_left", "
               "right/bumper", "right/trigger", "right/grip", "right/thumbstick")
 VR_DEVICE = "frame_controller"  # the id controller buttons have in watch events
 SCREENS = "\0ft_screens"
+FLOAT = "\0frametop_float"  # ft-floatd; floating windows in the Frametop desktop
+# Actions for ft-floatd: work even when pointer mode is off.
+FLOAT_ACTIONS = {"float_toggle": b"float pointer", "dock_all": b"dock all"}
+# Key combinations a rules file without "key_bindings" gets. Meta+Shift+F floats/docks
+# a window (free on the Frametop desktop; apps rarely use Meta+Shift+F). Gaze shortcuts
+# are not included — this fork keeps attention opacity without gaze mode.
+DEFAULT_KEY_BINDINGS = {"42+125+33": "float_toggle"}  # Shift+Meta+F
+KEY_F24 = 194  # sent to the desktop with a Meta combination (see key_binding)
+# Key combinations ("key_bindings"): modifiers, each side's code folded into the left one's.
+MODIFIERS = {29: 29, 97: 29, 42: 42, 54: 42, 56: 56, 100: 56, 125: 125, 126: 125}
+
+
+def known_action(a):
+    return a in ACTIONS
+
+
+def needs_pointer(a):
+    return a not in FLOAT_ACTIONS
 KEYS = "\0frametop_keys"  # keys of keyboards grabbed for the desktop, for other readers
 FT_LAYOUT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "layout", "ft-layout")
 DEFAULT_BUTTONS = {BTN_LEFT: "left", BTN_RIGHT: "right", BTN_MIDDLE: "middle",
@@ -292,7 +313,12 @@ def read_config(path=os.path.expanduser("~/.config/frametop.conf")):
 def read_rules(path=RULES_PATH):
     """{"devices": {id: {"role", "name"}}, "buttons": {id: {"<code>": action}},
     "controller_buttons": {"<hand>/<button>": action}, "controller_in_games": bool,
-    "vr_keyboard": one of VR_KEYBOARD_MODES, "vr_keyboard_persist": bool}."""
+    "key_bindings": {"<code>+<code>...": action},
+    "vr_keyboard": one of VR_KEYBOARD_MODES, "vr_keyboard_persist": bool}.
+
+    A rules file without "key_bindings" gets DEFAULT_KEY_BINDINGS (Meta+Shift+F:
+    float_toggle); one with its own list, even an empty one, does not.
+    """
     try:
         with open(path) as f:
             rules = json.load(f)
@@ -301,6 +327,8 @@ def read_rules(path=RULES_PATH):
     rules.setdefault("devices", {})
     rules.setdefault("buttons", {})
     rules.setdefault("controller_buttons", {})
+    if not isinstance(rules.get("key_bindings"), dict):
+        rules["key_bindings"] = dict(DEFAULT_KEY_BINDINGS)
     return rules
 
 
@@ -684,14 +712,72 @@ def main():
             vr_keyboard("show")
 
     def do_action(action, value, now):
-        """A mapped mouse or controller button (pointer mode only)."""
+        """A mapped mouse or controller button (pointer mode only, except FLOAT_ACTIONS)."""
         if action == "keyboard_toggle":
             if value == 1 and vr_keyboard_mode() != "never":
                 vr_keyboard("toggle")
+        elif action in FLOAT_ACTIONS:
+            if value == 1:
+                try:
+                    screens_sock.sendto(FLOAT_ACTIONS[action], FLOAT)
+                except OSError:
+                    pass  # Frametop desktop / ft-floatd not running
+                log(action)
         else:
             state["pointer"].action(action, value, now)
 
 
+    held_modifiers = set()  # on any keyboard, folded (MODIFIERS)
+    held_meta = set()  # the Meta keys held, as they are (KEY_LEFTMETA, KEY_RIGHTMETA)
+    meta_hidden = set()  # held Meta keys the desktop was told came up (a combination; key_binding)
+    combos_down = {}  # key code -> the action its combination started (released with it)
+
+    def key_binding(code, value, now):
+        """A key from a keyboard: does it complete a key combination ("key_bindings")?
+
+        True if it was taken for one (then it isn't typed).
+        """
+        nonlocal meta_down
+        if code in MODIFIERS:
+            (held_modifiers.add if value else held_modifiers.discard)(MODIFIERS[code])
+            if code in (KEY_LEFTMETA, KEY_RIGHTMETA):
+                (held_meta.add if value else held_meta.discard)(code)
+                if value == 0 and code in meta_hidden:
+                    meta_hidden.discard(code)
+                    return True  # the desktop already had it come up (below)
+            return False
+        if value == 1 and code not in combos_down and meta_hidden:
+            # Another key while Meta is still held after a combination: the desktop gets Meta
+            # back first, so Meta+that key still works there.
+            for c in sorted(meta_hidden):
+                to_screens(c, 1)
+            meta_hidden.clear()
+        if value == 0 and code in combos_down:
+            action = combos_down.pop(code)
+            if state["pointer"] or not needs_pointer(action):
+                do_action(action, 0, now)
+            return True
+        if value != 1 or not state["rules"]["key_bindings"]:
+            return value == 2 and code in combos_down
+        combo = "+".join(str(c) for c in sorted(held_modifiers) + [code])
+        action = state["rules"]["key_bindings"].get(combo)
+        if not known_action(action) or action in ("key", "none"):
+            return False
+        combos_down[code] = action
+        if held_meta - meta_hidden:
+            # The desktop saw Meta go down. Swallow it there now so Plasma's launcher and
+            # Meta+mouse window move/resize don't fire; the real Meta release is dropped above.
+            meta_down = False
+            to_screens(KEY_F24, 1)
+            to_screens(KEY_F24, 0)
+            for c in sorted(held_meta - meta_hidden):
+                to_screens(c, 0)
+            meta_hidden.update(held_meta)
+        if state["pointer"] or not needs_pointer(action):
+            do_action(action, 1, now)
+        log(f"key combination {combo}: {action}")
+        return True
+
     screens_down = set()  # keys the desktop was told went down and not yet up (see reconcile_desktop_keys)
 
     def to_screens(code, value):
diff --git a/pointer/helper/ft-pointer.cpp b/pointer/helper/ft-pointer.cpp
index e666dbf..96677e4 100644
--- a/pointer/helper/ft-pointer.cpp
+++ b/pointer/helper/ft-pointer.cpp
@@ -281,6 +281,19 @@ std::string ExeDir() {
     return p.substr(0, p.rfind('/'));
 }
 
+// A Frametop desktop panel the laser can drag across: a screen (frametop.screen.N), a floating
+// window (frametop.float.N), or a floating window's popup (frametop.float.N.sub.K), not a
+// control of theirs.
+bool FramePanel(const std::string &key) {
+    for (const char *prefix : {"frametop.screen.", "frametop.float."}) {
+        if (key.rfind(prefix, 0) != 0) continue;
+        const std::string rest = key.substr(std::strlen(prefix));
+        const size_t dot = rest.find('.');
+        return dot == std::string::npos || rest.compare(dot, 5, ".sub.") == 0;
+    }
+    return false;
+}
+
 void SendTo(int fd, const char *name, const std::string &msg) {
     sockaddr_un addr{};
     addr.sun_family = AF_UNIX;
@@ -421,7 +434,7 @@ std::vector<std::string> ParseIgnore(const std::string &list) {
 }
 
 bool Ignored(const std::vector<std::string> &patterns, const std::string &key) {
-    if (key.rfind("frametop.", 0) == 0) return false;  // screens, keyboard, future panels
+    if (key.rfind("frametop.", 0) == 0) return false;  // screens, floats, keyboard, instruments
     for (const auto &p : patterns)
         if (fnmatch(p.c_str(), key.c_str(), FNM_NOESCAPE) == 0) return true;
     return false;
@@ -620,6 +633,11 @@ int main() {
     bool leftHeld = false, tilting = false, tiltStart = false, swallowedRight = false;
     double tiltYaw = 0, tiltPitch = 0;
     double dragDistance = 0, lastDistance = 1.5;  // drag lock: distance from the anchor at the press
+    // While left is held on a FramePanel that hasn't moved yet, retarget dragDistance across
+    // other FramePanels (floating windows span multiple overlays). Cleared once the pressed
+    // panel moves (title-bar carry / screen drag).
+    std::string pressKey;
+    vr::HmdMatrix34_t pressPose{};
     bool onVrSettings = false;       // the cursor is on the SteamVR Settings page (kept while dragging)
     bool catcherHidesHit = false;    // the laser-catching dot hides SteamVR's hit dot (Settings page)
     Clock::time_point dropHoldUntil{};  // after a left release: keep the drag pose this long
@@ -687,6 +705,14 @@ int main() {
         nudging = false;
         leftHeld = true;
         dragDistance = lastDistance;
+        pressKey.clear();
+        if (FramePanel(lastHit)) {
+            vr::ETrackingUniverseOrigin uo;
+            auto it = handles.find(lastHit);
+            if (it != handles.end() &&
+                overlay->GetOverlayTransformAbsolute(it->second, &uo, &pressPose) == vr::VROverlayError_None)
+                pressKey = lastHit;
+        }
         tiltYaw = tiltPitch = 0;  // a new drag starts untilted
         dropHoldUntil = {};
         pulseAt = Clock::now();
@@ -698,6 +724,9 @@ int main() {
         // Hold the drag pose (tilt, frozen distance) while SteamVR finishes the drop.
         dropHoldUntil = Clock::now() + std::chrono::milliseconds(500);
         SendTo(out, "ft_pointer", "btn trigger 0");
+        // ft-screens releases a button held on its screens in KWin even when SteamVR hands
+        // the release to some other overlay (its catcher usually gets it; this is the backstop).
+        SendTo(out, "ft_screens", "up");
         if (gazeBack) gazeOwns = true, gazeBack = false;
     };
     // The left button, from the relay's "btn trigger", with gaze mode's held-back press (see
@@ -1257,7 +1286,7 @@ int main() {
                 overlay->GetOverlayTextureSize(h, &tw, &th);
                 vr::VROverlayTransformType tt = vr::VROverlayTransform_Invalid;
                 overlay->GetOverlayTransformType(h, &tt);
-                // ft-screens' panels (frametop.screen.N, the keyboard) are 0x0 and absolute too
+                // ft-screens' panels (frametop.screen.N, frametop.float.N, the keyboard) are 0x0 and absolute too
                 // (a shared texture), but they're real panels of any size.
                 sceneGraph[key] = (tw == 0 || th == 0) && tt == vr::VROverlayTransform_Absolute &&
                                   key.rfind("frametop.", 0) != 0;
@@ -1366,6 +1395,37 @@ int main() {
                     }
                 }
             }
+
+            // While left is held on a still FramePanel, let the locked ray retarget across other
+            // FramePanels (floating windows / their popups). Once that panel moves, the lock holds.
+            if (leftHeld && !pressKey.empty()) {
+                vr::ETrackingUniverseOrigin uo;
+                vr::HmdMatrix34_t now{};
+                auto it = handles.find(pressKey);
+                bool still = it != handles.end() &&
+                             overlay->GetOverlayTransformAbsolute(it->second, &uo, &now) == vr::VROverlayError_None;
+                for (int i = 0; still && i < 3; ++i)
+                    for (int j = 0; j < 4; ++j)
+                        if (std::fabs(now.m[i][j] - pressPose.m[i][j]) > 0.001f) still = false;
+                if (still) {
+                    Hit h;
+                    for (const auto &[key, handle] : handles) {
+                        if (!visible[key] || !FramePanel(key)) continue;
+                        vr::VROverlayIntersectionParams_t params{};
+                        params.vSource = {float(anchor.x), float(anchor.y), float(anchor.z)};
+                        params.vDirection = {float(dir.x), float(dir.y), float(dir.z)};
+                        params.eOrigin = vr::TrackingUniverseStanding;
+                        vr::VROverlayIntersectionResults_t r{};
+                        if (overlay->ComputeOverlayIntersection(handle, &params, &r) && r.fDistance > 0.05f &&
+                            r.fDistance < h.along)
+                            h.along = r.fDistance, h.key = key;
+                    }
+                    if (h.along < 1e8) dragDistance = h.along, lastHit = h.key;
+                } else {
+                    pressKey.clear();  // carried: the lock holds for the rest of this press
+                }
+            }
+
             // While dragging: keep the press-time distance and show the non-interactive marker.
             // On a scene-graph plane or a panel's edge: the laser-catching dot goes 5 cm behind it.
             double distance = dragging ? dragDistance : (best < 1e8 ? best : freeDistance);
diff --git a/test/test_float_phase3.py b/test/test_float_phase3.py
new file mode 100644
index 0000000..4c7372e
--- /dev/null
+++ b/test/test_float_phase3.py
@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""Phase 3A/B: floating-window wiring, ownership, crop math, conceal, pointer guard.
+
+Headless source/unit checks (no SteamVR). Run:
+
+  python3 test/test_float_phase3.py
+"""
+from __future__ import annotations
+
+import ast
+import math
+import re
+import tempfile
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def read(rel: str) -> str:
+    return (ROOT / rel).read_text(encoding="utf-8", errors="replace")
+
+
+class FloatNativeWiring(unittest.TestCase):
+    def test_compositor_spares_and_capacity(self):
+        c = read("screens/compositor.c")
+        m = re.search(r"#define\s+MAX_SCREENS\s+(\d+)", c)
+        self.assertIsNotNone(m)
+        self.assertGreaterEqual(int(m.group(1)), 24)
+        self.assertIn("--spares", c)
+        self.assertIn("ft_vr_float_create", c)
+        self.assertIn("ft_vr_float_output", c)
+
+    def test_vr_float_lifecycle_commands(self):
+        vr = read("screens/vr.cpp")
+        self.assertIn("frametop.float.", vr)
+        self.assertIn("frametop.float.%d.sub.%d", vr)
+        self.assertIn("void SetFloat(", vr)
+        self.assertIn("void Unfloat(", vr)
+        self.assertIn("void CropOverlay(", vr)
+        self.assertRegex(vr, r'sscanf\(cmd,\s*"float ')
+        self.assertRegex(vr, r'sscanf\(cmd,\s*"unfloat ')
+        self.assertIn('strcmp(cmd, "up")', vr)
+        # alone/conceal must not treat floats as real screens
+        self.assertIn("if (!s.floating) fn(s)", vr)
+
+    def test_session_spares_wiring(self):
+        s = read("session/frametop-session.sh")
+        self.assertIn("FLOAT_SLOTS", s)
+        self.assertIn("--spares", s)
+        self.assertIn("ft-floatd", s)
+
+
+class RealVsSpareOwnership(unittest.TestCase):
+    def test_layout_filters_spare_outputs(self):
+        layout = read("layout/ft_layout.py")
+        self.assertIn("spares for floating windows", layout)
+        # outputs() must skip indices past FT_SCREEN_COUNT / screen count
+        self.assertIn("def outputs(", layout)
+        block = layout[layout.find("def outputs(") : layout.find("def outputs(") + 1200]
+        self.assertTrue(
+            "FT_SCREEN_COUNT" in block or "screen_count" in block or "n_screens" in block or "spare" in block.lower(),
+            "outputs() should mention screen count / spares",
+        )
+
+    def test_floatd_owns_spares_layout_does_not(self):
+        floatd = read("float/ft_floatd.py")
+        self.assertIn("kscreen-doctor", floatd)
+        self.assertIn("spare", floatd.lower())
+        # first spare index == real screen count (0-based output index == screens_n)
+        self.assertRegex(floatd, r"screens_n|FT_SCREEN_COUNT")
+
+
+class CropAndInputMapping(unittest.TestCase):
+    """Verify crop math: panel shows window frame; margin pads output; pointer maps through crop."""
+
+    def test_crop_from_window_and_margin(self):
+        # Mirror ft-floatd / SetFloat contract: output geometry = window + margin on each side;
+        # crop is the window rectangle inside that output.
+        margin = 300
+        win_x, win_y, win_w, win_h = 100, 80, 800, 600
+        out_x = win_x - margin
+        out_y = win_y - margin
+        out_w = win_w + 2 * margin
+        out_h = win_h + 2 * margin
+        crop_x = win_x - out_x  # == margin
+        crop_y = win_y - out_y
+        crop_w, crop_h = win_w, win_h
+        self.assertEqual(crop_x, margin)
+        self.assertEqual(crop_y, margin)
+        self.assertEqual(crop_w, 800)
+        self.assertEqual(crop_h, 600)
+        # Pointer: UV in cropped panel -> output pixels
+        u, v = 0.0, 0.0  # top-left of visible panel == window top-left
+        ox = out_x + crop_x + u * crop_w
+        oy = out_y + crop_y + v * crop_h
+        self.assertEqual(ox, win_x)
+        self.assertEqual(oy, win_y)
+        u, v = 1.0, 1.0
+        ox = out_x + crop_x + u * crop_w
+        oy = out_y + crop_y + v * crop_h
+        self.assertEqual(ox, win_x + win_w)
+        self.assertEqual(oy, win_y + win_h)
+
+    def test_setfloat_uses_crop_fields(self):
+        vr = read("screens/vr.cpp")
+        # SetFloat stores crop and calls CropOverlay
+        i = vr.find("void SetFloat(")
+        self.assertGreater(i, 0)
+        body = vr[i : i + 900]
+        self.assertIn("ApplyCrop", body)
+        self.assertIn("cropX", body)
+        self.assertIn("cropW", body)
+
+
+class ConcealDocking(unittest.TestCase):
+    def test_floatd_dock_fallback_when_origin_concealed(self):
+        floatd = read("float/ft_floatd.py")
+        self.assertIn("def concealed(", floatd)
+        self.assertIn("hidden now", floatd)
+        self.assertIn("on_hidden_screen", floatd)
+        self.assertIn('ask("concealed"', floatd)
+
+    def test_vr_alone_skips_floating(self):
+        vr = read("screens/vr.cpp")
+        self.assertIn("if (!s.floating) fn(s)", vr)
+
+
+class PointerFloatTargeting(unittest.TestCase):
+    def test_frame_panel_and_up(self):
+        p = read("pointer/helper/ft-pointer.cpp")
+        self.assertIn("bool FramePanel(", p)
+        self.assertIn('"frametop.float."', p)
+        self.assertIn('"frametop.screen."', p)
+        self.assertIn(".sub.", p)
+        self.assertIn('SendTo(out, "ft_screens", "up")', p)
+        self.assertIn("pressKey", p)
+        # Fork-specific guards preserved
+        self.assertIn('key.rfind("frametop.", 0) == 0) return false', p)
+        self.assertIn("onVrSettings", p)
+
+    def test_pointer_ignore_rejects_float_globs(self):
+        # Reuse the same guard semantics as test_pointer_ignore.py
+        p = read("pointer/helper/ft-pointer.cpp")
+        self.assertIn("frametop.*", p)
+        # FramePanel must accept float overlays
+        self.assertRegex(p, r'frametop\.float\.')
+
+
+class FloatTogglePath(unittest.TestCase):
+    def test_relay_default_meta_shift_f(self):
+        relay = read("input/input-relay.py")
+        self.assertIn("DEFAULT_KEY_BINDINGS", relay)
+        self.assertIn('"42+125+33": "float_toggle"', relay)
+        self.assertIn("def key_binding(", relay)
+        self.assertIn("FLOAT_ACTIONS", relay)
+        self.assertNotIn("gaze_left", relay)  # do not import gaze shortcuts
+
+    def test_read_rules_injects_defaults(self):
+        # Load read_rules without running main
+        import importlib.util
+
+        spec = importlib.util.spec_from_file_location(
+            "input_relay_float_test", ROOT / "input" / "input-relay.py"
+        )
+        mod = importlib.util.module_from_spec(spec)
+        # Avoid executing side effects at import — file only defines helpers at top level.
+        # Executing the whole module is fine: no main() call.
+        spec.loader.exec_module(mod)
+        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as f:
+            f.write("{}")
+            path = f.name
+        try:
+            rules = mod.read_rules(path)
+            self.assertEqual(rules["key_bindings"].get("42+125+33"), "float_toggle")
+        finally:
+            Path(path).unlink(missing_ok=True)
+        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as f:
+            f.write('{"key_bindings": {}}')
+            path = f.name
+        try:
+            rules = mod.read_rules(path)
+            self.assertEqual(rules["key_bindings"], {})
+        finally:
+            Path(path).unlink(missing_ok=True)
+
+    def test_no_spare_fails_safe_in_floatd(self):
+        floatd = read("float/ft_floatd.py")
+        self.assertIn("floating windows are in use", floatd)
+        self.assertIn("Put one back on the desktop", floatd)
+
+
+class NamespaceProtection(unittest.TestCase):
+    def test_ignore_never_drops_frametop_float(self):
+        p = read("pointer/helper/ft-pointer.cpp")
+        # Extract Ignored() body
+        i = p.find("bool Ignored(")
+        self.assertGreater(i, 0)
+        body = p[i : i + 500]
+        self.assertIn('rfind("frametop.", 0) == 0) return false', body)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_vr_keyboard_relay.py b/test/test_vr_keyboard_relay.py
index b260b56..896449f 100644
--- a/test/test_vr_keyboard_relay.py
+++ b/test/test_vr_keyboard_relay.py
@@ -82,7 +82,10 @@ def test_constants():
     with tempfile.TemporaryDirectory() as td:
         path = os.path.join(td, "rules.json")
         check("read_rules missing file keeps shape",
-              relay.read_rules(path) == {"devices": {}, "buttons": {}, "controller_buttons": {}})
+              relay.read_rules(path) == {
+                  "devices": {}, "buttons": {}, "controller_buttons": {},
+                  "key_bindings": dict(relay.DEFAULT_KEY_BINDINGS),
+              })
         with open(path, "w") as f:
             json.dump({"vr_keyboard": "button", "vr_keyboard_persist": False}, f)
         r = relay.read_rules(path)