fix(ui): reconcile PR 66 with current main

fix(input): cancel old headset input when switching routes
Merge origin/main into pad-gamescope
2026-10-21 01:01:38 +02:00 · 2026-10-18 00:37:13 +00:00 · 2026-10-17 23:55:09 +00:00 · 2026-10-01 21:06:06 +10:00 · 2026-10-01 21:01:53 +10:00 · 2026-10-01 20:57:08 +10:00
17 changed files with 491 additions and 718 deletions
@@ -73,7 +73,7 @@ Drag files onto the window to send them. Drop a game's .zip, folder or .exe to a
 Browse the shots you take in the headset and save them to your Pictures folder.

 **⌨️ Keyboard and trackpad**<br>
-Type and point in the Frame's apps from your computer or phone, through KDE Connect, which Frame Control brings along and sets up on the Frame. Nothing else to install, anywhere.
+Type and point in the headset from your computer or phone, through Valve's own input path, with nothing to install. Accents and emoji use KDE Connect, which Frame Control brings along and sets up the first time you type one.

 </td>
 </tr>
@@ -1,12 +1,12 @@
 {
  "name": "frame-control",
-  "version": "0.4.8",
+  "version": "0.4.7",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "frame-control",
-      "version": "0.4.8",
+      "version": "0.4.7",
      "license": "MIT",
      "devDependencies": {
        "electron": "^44.4.5",
@@ -1,7 +1,7 @@
 {
  "name": "frame-control",
  "productName": "Frame Control",
-  "version": "0.4.8",
+  "version": "0.4.7",
  "description": "Desktop app for managing a Valve Steam Frame over SSH",
  "private": true,
  "main": "main.js",
@@ -1,57 +0,0 @@
-# Import an Android game backup
-
-A SideQuest backup can contain a small APK and much larger `main.…obb` and
-`patch.…obb` files. All of them belong to the same game. Installing only the APK
-can leave the game unable to start because its assets are missing.
-
-In **Android → Import game files…**, choose the APK and its OBB files together.
-You can also drop them anywhere in the window. In the desktop app, dropping the
-APK alone finds matching OBB files beside it; dropping a folder containing the
-APK and OBBs also works. Browsers can read only the files you explicitly choose.
-
-The import screen shows the game app and its game-data files together. **Import
-game & data** installs the APK, starts its own Steam library instance, waits for
-Android and the installed package, copies the OBBs, and closes the game. Open it
-again from the Steam library to play. The screen explains this before import;
-choosing files alone never starts a game.
-
-Files are matched using the package inside the APK and the standard
-`main|patch.<version>.<package>.obb` name, not the APK's filename. Both main and
-patch files are preserved. OBB version numbers need not equal the APK's current
-version code: updates can reuse older expansion files. The copy uses the existing
-SHA-256 transfer check inside Android and writes to that game's own
-`/sdcard/Android/obb/<package>` folder.
-
-If no data files are selected, the screen reminds you to include any OBBs in the
-backup before offering **Install game app**. An APK cannot reliably tell Frame
-Control whether separate expansion files are required. Game-data files are never
-silently sent to Downloads by this flow.
-
-If setup fails, the import screen keeps the error and retry instructions visible.
-The APK may already be installed, but the game is not reported ready. Import the
-same backup again, or choose just its OBB files to add data to an existing install.
-The importer checks the installed package and version before writing data and
-closes the instance after a failed copy. Unrelated or duplicate files, running
-games that would be replaced, and downgrades are rejected. Uploaded staging files
-are discarded after use or cancellation; abandoned imports expire after an hour
-when the importer is next used, and dead-server staging folders are swept at
-startup.
-
-This flow handles one ordinary APK and standard OBB files for one game at a time.
-Split APKs, XAPK/APKS archives, nested Android/data folders and private save
-archives need their own import handling. PC ZIP/folder/EXE imports keep their
-existing route. Quest USB and Meta library imports keep their existing workflow.
-
-Validation covers actual APK parsing, the three-file backup layout, package
-matching, sibling discovery, browser upload staging and cleanup, instance/version
-guards and failure recovery with mocked headset operations. Browser verification
-uses the real page and upload/inspection endpoints with simulated installation.
-**Verified 2026-10-20 on a real Steam Frame**, BUILD_ID `20260925.6191901`:
-F-Droid Basic 2.0.2 with two synthetic main/patch OBBs completed the automatic
-install/start/copy/close sequence. Reopening its persistent instance confirmed
-both SHA-256 hashes in `/sdcard/Android/obb/org.fdroid.basic`. The test app,
-shortcut and instance were removed afterward, the shared device lock was
-released, and the battery remained at 99%. See [device evidence](evidence/android-import/device.json).
-The headset was unworn; this checks transfer and persistence, not rendering,
-Resident Evil 4 gameplay, or a game that exits before data can be copied. This
-flow does not change APK compatibility or remove licence checks.
@@ -1,34 +0,0 @@
-{
-  "date": "2026-10-20T03:53:25Z",
-  "build_id": "20260925.6191901",
-  "app": "F-Droid Basic 2.0.2 (org.fdroid.basic, version code 2000052)",
-  "input": "One real APK plus synthetic main and patch OBBs named with older version code 2000050",
-  "sibling_discovery": true,
-  "automatic_import": "passed",
-  "closed_after_import": true,
-  "independent_readback": [
-    "5023b41e7ac80f8b26a868db1f66884976bf864fab81a070ad37539f3481b352  /sdcard/Android/obb/org.fdroid.basic/main.2000050.org.fdroid.basic.obb",
-    "aecbed7433e81aaeef40942069d03ad23130f09d93b7e78bbe224865a9573157  /sdcard/Android/obb/org.fdroid.basic/patch.2000050.org.fdroid.basic.obb"
-  ],
-  "cleanup": {
-    "test_install_removed": true,
-    "running_instances_before": {},
-    "running_instances_after": {},
-    "battery_before": [
-      "100",
-      "Full",
-      "Charging"
-    ],
-    "battery_after": [
-      "99",
-      "Discharging",
-      "Charging"
-    ],
-    "shared_lock_released": true
-  },
-  "limits": [
-    "No headset rendering or gameplay assertion; headset unworn.",
-    "Synthetic expansion files verify transport and persistence, not Resident Evil 4 compatibility.",
-    "A game that exits before its Lepton instance can accept data was not tested."
-  ]
-}
@@ -24,7 +24,7 @@ No SideQuest implementation code was copied.
 | Installed-app management (launch, uninstall, backup) | List, launch, stop, remove, probe | Already mostly covered. Backup added here. |
 | Update notices / account library | Compatible-version lookup; no source-aware installed update notices | Useful later, medium; needs original version code and source identity recorded on install. |
 | Custom repositories | Built-in F-Droid catalogue and compatible-version indexes | Separate user-repos worker. Legacy SideQuest source has a fixed SideQuestRepos index; arbitrary current custom-repo support was not verified. |
-| Drag-and-drop APK/OBB install | APK drag-and-drop already works | The [Android backup importer](android-backups.md) now groups the APK and matching OBBs, detects desktop siblings and guides installation and data setup. |
+| Drag-and-drop APK/OBB install | APK drag-and-drop already works | OBB backend added here; future UI can call it. UI drop wiring is not included. |
 | Tags, price, headset filters, reviews | Text search and Lepton verdicts, not Quest headset metadata | Useful, medium; search worker owns filters. Keep source headset claims distinct from tested Frame compatibility. |
 | Screenshot/video capture and streaming | Frame screenshots/VR capture already present | Reuse existing tools; do not port Quest capture commands. |
 | Device settings and ADB utilities | Frame/Android display settings, SSH and own-instance tools | Borrow selectively; Quest CPU/GPU presets and wireless-ADB setup do not map directly to Lepton. |
@@ -85,9 +85,6 @@ local SHA-256 alone must not be called publisher verification.

 ## OBB files

-For the app's guided APK and OBB import, see [Import an Android game backup](android-backups.md).
-The CLI helper below remains available for a running instance.
-
 ```sh
 python3 ui/frame_android.py install-obb org.example.game main.42.org.example.game.obb
 python3 ui/frame_android.py install-obb org.example.game main.42.org.example.game.obb patch.42.org.example.game.obb
@@ -151,10 +151,13 @@ two fingers to scroll, two-finger tap to right-click) plus a text field that
 types on the Frame. On a computer, clicking the pad passes your mouse and
 keyboard through to the Frame until you press Esc (⌘ is sent as Ctrl on a Mac).

-It goes through **KDE Connect**, the first-party route (KDE makes the Frame's
-desktop): Frame Control's server runs [`ui/frame_input_agent.py`](../ui/frame_input_agent.py)
-on the Frame, which talks KDE Connect's own LAN protocol to the Frame's
-`kdeconnectd` as if it were a phone. KDE Connect does the typing and clicking.
+Since Control (below), the pad goes through **gamescope's own input socket**
+([`ui/frame_touch.py`](../ui/frame_touch.py)), so it reaches whichever panel has
+focus, Steam's own menus included, and needs nothing installed on the Frame.
+Only characters that aren't on a US keyboard (accents, emoji) go through
+**KDE Connect** as below; it starts the first time you type one. (Before
+Control, everything went through KDE Connect, which is why the notes below
+describe it in detail.)

 **Verified 2026-09-28** (SteamOS 0.4.1, build 20260925.6191901):

@@ -1,177 +0,0 @@
-"""Local APK/OBB backups: inspect as a unit, verify the target, and finish setup."""
-import sandbox  # noqa: F401
-import io
-from pathlib import Path
-import sys
-import tempfile
-import unittest
-from unittest.mock import patch
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'ui'))
-import frame_android_import as backup
-import server
-from apk_fixtures import apk, manifest
-
-PKG = 'com.Armature.VR4'
-META = {'package': PKG, 'label': PKG, 'version': '', 'version_code': 210,
-        'instance': 2800000001, 'shortcut': 123, 'game_id': 456}
-
-
-class BackupTests(unittest.TestCase):
-    def setUp(self):
-        self.tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self.tmp.cleanup)
-        self.root = Path(self.tmp.name)
-        self.apk = self.root / 'VR4-Android-Shipping-arm64.apk'
-        self.apk.write_bytes(apk({'AndroidManifest.xml': manifest(PKG, 0x7f010000, 0x7f010001, 26)}))
-        self.obb = [self.root / f'{kind}.203.{PKG}.obb' for kind in ('main', 'patch')]
-        for p in self.obb:
-            p.write_bytes(b'game data')
-
-    def test_desktop_apk_finds_matching_siblings_but_browser_requires_selection(self):
-        (self.root / 'main.1.org.other.game.obb').write_bytes(b'other game')
-        with patch.object(backup.android, 'ssh') as ssh:
-            desktop = backup.inspect([str(self.apk)], discover=True)
-            browser = backup.inspect([str(self.apk)])
-            selected = backup.inspect([str(self.apk), *map(str, self.obb)])
-        ssh.assert_not_called()
-        self.assertEqual(desktop['obb'], self.obb)
-        self.assertEqual(browser['obb'], [])
-        self.assertEqual(backup.public(selected)['obb'][0]['name'], self.obb[0].name)
-        self.assertEqual(backup.public(selected)['package'], PKG)
-        self.assertNotIn(str(self.root), str(backup.public(selected)))
-
-    def test_wrong_data_empty_data_duplicate_names_and_multiple_apks_fail_before_install(self):
-        other = self.root / 'main.203.org.other.game.obb'
-        other.write_bytes(b'other game')
-        with self.assertRaisesRegex(backup.android.FrameError, 'does not belong'):
-            backup.inspect([str(self.apk), str(other)])
-        self.obb[0].write_bytes(b'')
-        with self.assertRaisesRegex(backup.android.FrameError, 'nonempty'):
-            backup.inspect([str(self.apk), str(self.obb[0])])
-        second = self.root / 'another.apk'
-        second.write_bytes(self.apk.read_bytes())
-        with self.assertRaisesRegex(backup.android.FrameError, 'one game at a time'):
-            backup.inspect([str(self.apk), str(second)])
-        self.obb[0].write_bytes(b'data')
-        folder = self.root / 'copy'
-        folder.mkdir()
-        duplicate = folder / self.obb[0].name
-        duplicate.write_bytes(b'data')
-        with self.assertRaisesRegex(backup.android.FrameError, 'unique names'):
-            backup.inspect([str(self.apk), str(self.obb[0]), str(duplicate)])
-
-    def test_obb_only_repairs_existing_game_and_requests_apk_when_not_installed(self):
-        with patch.object(backup.android, 'read_meta', return_value=None):
-            with self.assertRaisesRegex(backup.android.FrameError, 'Add its APK'):
-                backup.inspect(list(map(str, self.obb)))
-        with patch.object(backup.android, 'read_meta', return_value=META):
-            plan = backup.inspect(list(map(str, self.obb)))
-        self.assertIsNone(plan['apk'])
-        self.assertEqual(plan['checked']['version_code'], 210)
-
-    def test_apk_and_both_data_files_install_launch_verify_copy_close_in_order(self):
-        plan = backup.inspect([str(self.apk), *map(str, self.obb)])
-        order = []
-        def added(pkg, checked, files, *args, **kwargs):
-            order.append('copy-close')
-            self.assertEqual(pkg, PKG)
-            self.assertEqual(files, self.obb)
-            return {'closed': True, 'message': 'copied', 'app': META, 'needs_game_data': False}
-        with patch.object(backup.quest, '_running', side_effect=[False, False, True]), \
-                patch.object(backup.android, 'read_meta', return_value=None), \
-                patch.object(backup.android, 'install', side_effect=lambda *a, **k: order.append('install') or META), \
-                patch.object(backup.android, 'launch', side_effect=lambda *a: order.append('launch')), \
-                patch.object(backup.quest, '_wait_ready', side_effect=lambda *a: order.append('ready')), \
-                patch.object(backup.quest, '_check_android_package', side_effect=lambda *a: order.append('verify')), \
-                patch.object(backup.quest, 'add_game_data', side_effect=added):
-            result = backup.install(plan)
-        self.assertEqual(order, ['install', 'launch', 'ready', 'verify', 'copy-close'])
-        self.assertIn('2 game-data files', result['message'])
-        self.assertIn('Ready to open', result['message'])
-
-    def test_copy_failure_closes_game_and_keeps_retry_instruction(self):
-        plan = backup.inspect([str(self.apk), *map(str, self.obb)])
-        with patch.object(backup.quest, '_running', side_effect=[False, True]), \
-                patch.object(backup.android, 'read_meta', return_value=None), \
-                patch.object(backup.android, 'install', return_value=META), \
-                patch.object(backup.quest, '_wait_ready'), patch.object(backup.quest, '_check_android_package'), \
-                patch.object(backup.quest, 'add_game_data', side_effect=backup.android.FrameError('transfer failed')), \
-                patch.object(backup.quest, '_close', return_value=(True, None)) as close:
-            with self.assertRaisesRegex(backup.android.FrameError, 'installed, but.*Import the same backup again'):
-                backup.install(plan)
-        close.assert_called_once_with(PKG)
-
-    def test_changed_files_are_rejected_before_frame_access(self):
-        plan = backup.inspect([str(self.apk), *map(str, self.obb)])
-        self.obb[0].write_bytes(b'changed contents')
-        with patch.object(backup.android, 'ssh') as ssh:
-            with self.assertRaisesRegex(backup.android.FrameError, 'backup changed'):
-                backup.install(plan)
-        ssh.assert_not_called()
-
-    def test_running_game_and_newer_installed_version_are_not_replaced(self):
-        plan = backup.inspect([str(self.apk), *map(str, self.obb)])
-        newer = {**META, 'version_code': plan['checked']['version_code'] + 1}
-        for running, existing, message in [(True, None, 'Close'), (False, newer, 'newer')]:
-            with self.subTest(running=running), \
-                    patch.object(backup.quest, '_running', return_value=running), \
-                    patch.object(backup.android, 'read_meta', return_value=existing), \
-                    patch.object(backup.android, 'install') as install:
-                with self.assertRaisesRegex(backup.android.FrameError, message):
-                    backup.install(plan)
-                install.assert_not_called()
-
-    def test_apk_without_data_installs_without_launching(self):
-        plan = backup.inspect([str(self.apk)])
-        with patch.object(backup.quest, '_running', return_value=False), \
-                patch.object(backup.android, 'read_meta', return_value=None), \
-                patch.object(backup.android, 'install', return_value=META), \
-                patch.object(backup.android, 'launch') as launch:
-            result = backup.install(plan)
-        launch.assert_not_called()
-        self.assertFalse(result['needs_game_data'])
-
-
-class StagingTests(unittest.TestCase):
-    setUp = BackupTests.setUp
-    def tearDown(self):
-        for entry in server._android_backups.values():
-            server._discard_android_backup(entry)
-        server._android_backups.clear()
-
-    def test_uploaded_batch_is_inspected_together_and_cancel_removes_all_uploads(self):
-        token = server.android_backup({'action': 'begin'})['token']
-        for path in [self.apk, *self.obb]:
-            class Request:
-                headers = {'X-Filename': path.name, 'X-Mode': 'android-backup',
-                           'X-Android-Backup': token, 'Content-Length': str(path.stat().st_size)}
-                rfile = io.BytesIO(path.read_bytes())
-            server.Handler.upload(Request())
-        read = server.android_backup({'action': 'inspect', 'token': token})
-        self.assertEqual(len(read['plan']['obb']), 2)
-        folders = list(server._android_backups[token]['dirs'])
-        server.android_backup({'action': 'discard', 'token': token})
-        self.assertTrue(all(not Path(p).exists() for p in folders))
-        self.assertTrue(self.apk.exists())
-
-    def test_headset_change_refuses_import_and_pc_folder_is_left_to_title_importer(self):
-        class Link:
-            device = 'a'
-            def active_device(self):
-                return {'id': self.device}
-        link = Link()
-        with patch.object(server, 'LINK', link):
-            read = server.android_backup({'action': 'inspect', 'paths': [str(self.apk)]})
-            link.device = 'b'
-            with self.assertRaisesRegex(server.Failure, 'headset changed'):
-                server.android_backup({'action': 'install', 'token': read['token']})
-        pc = self.root / 'pc'
-        pc.mkdir()
-        (pc / 'game.exe').write_bytes(b'program')
-        self.assertEqual(server.android_backup({'action': 'inspect', 'paths': [str(pc)], 'probe': True}),
-                         {'android': False})
-
-
-if __name__ == '__main__':
-    unittest.main()
@@ -323,15 +323,6 @@ class Pins(Base):


 class Registry(Base):
-    def test_replaced_registry_is_read_even_when_timestamp_and_size_match(self):
-        d = self.reg.add_device('frame', name='First')
-        before = self.reg.path.stat()
-        other = fd.Registry(self.reg.path)
-        other.update_device(d['id'], name='Other')
-        os.utime(self.reg.path, ns=(before.st_atime_ns, before.st_mtime_ns))
-        self.assertEqual(self.reg.path.stat().st_size, before.st_size)
-        self.assertEqual(self.reg.get(d['id'])['name'], 'Other')
-
    def test_an_address_added_first_wins_on_its_own_network(self):
        # The page's "Add 192.168.x.x" offer: the headset is reached over Tailscale, which has
        # worked here before. The LAN address has to go ahead of it to be used at home.
@@ -18,6 +18,7 @@ import tempfile
 import threading
 import time
 import unittest
+from unittest import mock
 from pathlib import Path

 ROOT = Path(__file__).resolve().parent.parent
@@ -631,3 +632,257 @@ class PageQueue(unittest.TestCase):

 if __name__ == "__main__":
    unittest.main()
+
+
+class PadEvents(unittest.TestCase):
+    """The trackpad and key row go through gamescope; accents and emoji go the KDE Connect way."""
+
+    @classmethod
+    def setUpClass(cls):
+        import server
+        cls.pad = staticmethod(server.pad_events)
+
+    def test_moves_clicks_and_scroll(self):
+        out, extra = self.pad([{"dx": 3, "dy": -2}, {"singleclick": True}, {"singlehold": True},
+                               {"singlerelease": True}, {"scroll": True, "dy": 1}, {"rightclick": True}])
+        self.assertEqual(out[0], {"dx": 3, "dy": -2})
+        self.assertEqual(out[1:3], [{"button": "left", "down": True}, {"button": "left", "down": False}])
+        self.assertEqual(out[3:5], [{"button": "left", "down": True}, {"button": "left", "down": False}])
+        self.assertEqual(out[5], {"scroll": [0, -15]})  # up = content follows the finger
+        self.assertEqual(out[6:], [{"button": "right", "down": True}, {"button": "right", "down": False}])
+        self.assertEqual(extra, [])
+
+    def test_keys_and_modifiers(self):
+        out, _ = self.pad([{"specialKey": 12}, {"specialKey": 1, "ctrl": True}, {"key": "c", "ctrl": True}])
+        self.assertEqual(out[:2], [{"key": 28, "down": True}, {"key": 28, "down": False}])
+        self.assertEqual([e["key"] for e in out[2:6]], [29, 14, 14, 29])  # Ctrl+Backspace
+        self.assertEqual([(e["key"], e["down"]) for e in out[6:]],
+                         [(29, True), (46, True), (46, False), (29, False)])  # Ctrl+C
+
+    def test_text_stays_ascii_through_gamescope(self):
+        out, slow = self.pad([{"key": "Hi "}, {"key": "there"}])
+        self.assertEqual(out, [{"text": "Hi there"}])
+        self.assertEqual(slow, [])
+
+    def test_keyboard_goes_to_kde_whole_and_in_order(self):
+        events = [{"key": "a"}, {"key": "é"}, {"specialKey": 12}, {"key": "c", "ctrl": True}, {"dx": 2, "dy": 1}]
+        out, slow = self.pad(events, kde=True)
+        self.assertEqual(out, [{"dx": 2, "dy": 1}])  # the pointer still goes through gamescope
+        self.assertEqual(slow, events[:4])  # the keyboard as sent, in order
+
+    def test_shifted_key_with_modifier(self):
+        out, _ = self.pad([{"key": "A", "ctrl": True}])
+        self.assertEqual([e["key"] for e in out], [29, 42, 30, 30, 42, 29])
+
+
+class PadDelivery(unittest.TestCase):
+    """remote_input's promises: "sent" means the whole batch is taken; accents go once, in order."""
+
+    class Agent:
+        def __init__(self, sent=True, state="ready"):
+            self.sent, self.state, self.got = sent, state, []
+
+        def send(self, events):
+            if events and self.sent:
+                self.got.append(events)
+            return {"state": self.state, "sent": self.sent and bool(events)}
+
+    def setUp(self):
+        import server
+        self.s = server
+        self.saved = (server._touch, server._input, server.KDE_WAIT)
+        server._touch, server._input = self.Agent(), self.Agent()
+        self.reset()
+
+    def tearDown(self):
+        self.s._touch, self.s._input, self.s.KDE_WAIT = self.saved
+        self.settle()
+        self.reset()
+
+    def reset(self):
+        self.s._kde_queue.clear()
+        self.s._kde_until = self.s._typed_until = 0.0
+        self.s._kde_worker[0] = None
+
+    def settle(self):
+        worker = self.s._kde_worker[0]
+        if worker:
+            worker.join(5)
+
+    def typed(self):
+        return [e for batch in self.s._input.got for e in batch]
+
+    def test_accent_only_batch_is_acknowledged_and_typed_once(self):
+        status = self.s.remote_input({"events": [{"key": "é"}]})
+        self.assertTrue(status["sent"])  # so the page doesn't send it again
+        self.settle()
+        self.assertEqual(self.typed(), [{"key": "é"}])
+
+    def test_mixed_text_stays_in_one_ordered_stream(self):
+        self.s.remote_input({"events": [{"key": "aéb"}, {"specialKey": 12}]})
+        self.settle()
+        self.assertEqual(self.typed(), [{"key": "aéb"}, {"specialKey": 12}])
+        self.assertEqual(self.s._touch.got, [])  # none of it split off through gamescope
+
+    def test_batch_gamescope_didnt_take_is_not_queued(self):
+        self.s._touch = self.Agent(sent=False, state="starting")
+        status = self.s.remote_input({"events": [{"dx": 1, "dy": 1}, {"key": "é"}]})
+        self.assertFalse(status["sent"])  # the page tries the whole batch again...
+        self.assertEqual(self.s._kde_queue, [])  # ...so the accent isn't queued twice
+
+    def test_waits_for_kde_connect_then_sends_without_more_input(self):
+        self.s._input = self.Agent(sent=False, state="starting")
+        self.s.remote_input({"events": [{"key": "é"}]})
+        time.sleep(0.2)
+        self.assertEqual(self.s._kde_queue, [{"key": "é"}])
+        self.s._input.sent = True
+        self.settle()
+        self.assertEqual(self.typed(), [{"key": "é"}])
+        self.assertEqual(self.s._kde_queue, [])
+
+    def test_later_ascii_waits_behind_a_pending_accent(self):
+        self.s._input = self.Agent(sent=False, state="starting")
+        self.s.remote_input({"events": [{"key": "é"}]})
+        self.s.remote_input({"events": [{"key": "x"}]})
+        self.assertEqual(self.s._touch.got, [])  # "x" can't overtake the "é"
+        self.assertEqual(self.s._kde_queue, [{"key": "é"}, {"key": "x"}])
+        self.s._input.sent = True
+        self.settle()
+        self.assertEqual(self.typed(), [{"key": "é"}, {"key": "x"}])
+
+    def test_queue_is_bounded_and_dropped_on_error(self):
+        self.s._input = self.Agent(sent=False, state="error")
+        self.s.remote_input({"events": [{"key": "é"}] * 150})
+        self.s.remote_input({"events": [{"key": "é"}] * 150})
+        self.settle()
+        self.assertEqual(self.s._kde_queue, [])
+        self.s._input = self.Agent(sent=False, state="starting")
+        self.s.KDE_WAIT = 0.3
+        self.s.remote_input({"events": [{"key": "é"}] * 150})
+        self.s.remote_input({"events": [{"key": "é"}] * 150})
+        self.assertLessEqual(len(self.s._kde_queue), self.s.KDE_QUEUE_LIMIT)
+        self.settle()
+        self.assertEqual(self.s._kde_queue, [])
+
+    def test_ascii_just_after_an_accent_stays_behind_it(self):
+        self.s.remote_input({"events": [{"key": "é"}]})
+        self.settle()
+        self.s.remote_input({"events": [{"key": "x"}]})  # KDE Connect may still be typing the é
+        self.settle()
+        self.assertEqual(self.s._touch.got, [])
+        self.assertEqual(self.typed(), [{"key": "é"}, {"key": "x"}])
+
+    def test_accent_just_after_gamescope_text_waits_for_it(self):
+        self.s.remote_input({"events": [{"key": "x" * 50}]})
+        self.assertEqual(self.s._touch.got, [[{"text": "x" * 50}]])
+        start = time.time()
+        self.s.remote_input({"events": [{"key": "é"}]})
+        self.settle()
+        self.assertGreater(time.time() - start, 0.6)  # 50 keys at 16 ms, plus the margin
+        self.assertEqual(self.typed(), [{"key": "é"}])
+
+    def test_typing_time_counts_every_key_transition(self):
+        t = self.s.typing_seconds
+        self.assertAlmostEqual(t([{"text": "ab"}]), 4 * 0.008)
+        self.assertAlmostEqual(t([{"text": "A"}]), 4 * 0.008)  # shift down, key down, key up, shift up
+        self.assertAlmostEqual(t([{"text": "x" * 500}]), 8.0)  # a long paste
+        self.assertAlmostEqual(t([{"key": 29, "down": True}, {"dx": 3, "dy": 0}]), 0.008)
+
+    def test_the_margin_is_added_once_not_per_request(self):
+        for _ in range(10):
+            self.s.remote_input({"events": [{"key": "ab"}]})
+        # ten requests of 4 transitions each: the work queues up, with no margin added per request
+        self.assertLess(self.s._typed_until - time.time(), 10 * 4 * 0.008 + 0.05)
+
+    def test_trimming_while_sending_doesnt_drop_unsent_events(self):
+        slow = self.Agent()
+        gate = threading.Event()
+        send = slow.send
+
+        def held(events):
+            gate.wait(5)
+            return send(events)
+        slow.send = held
+        self.s._input = slow
+        self.s.remote_input({"events": [{"key": "é"}] * 150})
+        time.sleep(0.2)  # the worker has taken its 150 and is mid-send
+        self.s.remote_input({"events": [{"key": "ü"}] * 150})
+        gate.set()
+        self.settle()
+        sent = self.typed()
+        self.assertEqual(sent[:150], [{"key": "é"}] * 150)
+        self.assertEqual(sent[150:], [{"key": "ü"}] * 150)  # none of the new ones went missing
+
+    def test_input_queued_as_the_worker_finishes_is_still_sent(self):
+        for _ in range(40):
+            self.reset()
+            self.s._input.got.clear()
+            self.s.remote_input({"events": [{"key": "é"}]})
+            time.sleep(0.002)
+            self.s.remote_input({"events": [{"key": "ü"}]})
+            self.settle()
+            self.assertEqual(self.s._kde_queue, [])
+            self.assertEqual(self.typed(), [{"key": "é"}, {"key": "ü"}])
+
+
+class PadRoute(unittest.TestCase):
+    def setUp(self):
+        import server
+        self.s = server
+        self.agents = mock.patch.multiple(server, _touch=mock.Mock(), _input=mock.Mock())
+        self.agents.start()
+        self.addCleanup(self.agents.stop)
+        self.s._touch.send.return_value = {"state": "ready", "sent": True}
+        self.s._input.send.return_value = {"state": "ready", "sent": True}
+        self.s.reset_pad_route()
+        self.s._touch.reset_mock(); self.s._input.reset_mock()
+        self.addCleanup(self.s.reset_pad_route)
+
+    def switch(self):
+        with mock.patch.multiple(self.s, FRAME="frame-a", HOST_OPTS=[], MUX=[], SSH=[], macview=None), \
+             mock.patch.multiple(self.s.frame_android, FRAME="frame-a", SSH_OPTS=[]):
+            self.s.route("frame-b", [])
+
+    def test_switch_stops_both_input_agents_and_discards_old_queue(self):
+        self.s._kde_queue.append({"key": "old"})
+        self.s._kde_until = self.s._typed_until = time.time() + 60
+        cancel = self.s._kde_cancel
+        self.switch()
+        self.s._input.stop.assert_called_once()
+        self.s._touch.stop.assert_called_once()
+        self.assertEqual(self.s._kde_queue, [])
+        self.assertEqual((self.s._kde_until, self.s._typed_until), (0, 0))
+        self.assertTrue(cancel.is_set())
+
+    def test_switch_cancels_delayed_and_retrying_text_before_new_input(self):
+        for delaying in (True, False):
+            with self.subTest(delaying=delaying):
+                waiting, cancel = threading.Event(), threading.Event()
+                class ObservedCancel:
+                    def wait(self, timeout):
+                        waiting.set()
+                        return cancel.wait(timeout)
+                    def set(self):
+                        cancel.set()
+                self.s.reset_pad_route()
+                self.s._kde_cancel = ObservedCancel()
+                self.s._typed_until = time.time() + 60 if delaying else 0
+                self.s._input.reset_mock()
+                self.s._input.send.return_value = {"state": "starting", "sent": False}
+                self.s.remote_input({"events": [{"key": "é"}]})
+                worker = self.s._kde_worker[0]
+                self.assertTrue(waiting.wait(1), "worker never reached its cancellable delay")
+                self.switch()
+                worker.join(1)
+                self.assertFalse(worker.is_alive())
+                attempts = self.s._input.send.call_count
+                self.assertEqual(attempts, 0 if delaying else 1)
+                self.s._input.send.return_value = {"state": "ready", "sent": True}
+                self.s.remote_input({"events": [{"key": "ü"}]})
+                next_worker = self.s._kde_worker[0]
+                if next_worker:
+                    next_worker.join(1)
+                    self.assertFalse(next_worker.is_alive())
+                self.assertEqual(self.s._input.send.call_count, attempts + 1)
+                self.assertEqual(self.s._input.send.call_args.args[0], [{"key": "ü"}])
+                self.assertEqual(self.s._kde_queue, [])
@@ -150,6 +150,14 @@ class Apply(unittest.TestCase):
        self.assertFalse(self.t.STALE[0])
        self.assertEqual(self.said[-1][1].get("stale"), None)

+    def test_stale_survives_a_bare_release(self):
+        gs = FakeGamescope()
+        panel = self.t.apply(gs, {"button": "left", "down": True, "window": 99, "display": ":1"}, None)
+        self.assertTrue(self.t.STALE[0])
+        self.t.apply(gs, {"button": "left", "down": False}, panel)  # the page's release names no panel
+        self.assertTrue(self.t.STALE[0])
+        self.assertEqual(self.said[-1][1].get("stale"), True)
+
    def test_same_window_id_on_the_other_display_is_another_panel(self):
        gs = FakeGamescope()
        self.t.apply(gs, {"fx": 0.5, "fy": 0.5, "window": 7, "display": ":0"}, None)
@@ -394,7 +394,7 @@ class ServerJobs(unittest.TestCase):
            places = s._tmp_places()
            self.assertEqual({p for _, p in places}, {s.WEB_TMP_PREFIX, s.frame_titles.TMP_PREFIX,
                                                      s.frame_android.TMP_PREFIX, s.frame_agent.TMP_PREFIX,
-                                                      s.apk_fdroid.TMP_PREFIX, s.ANDROID_BACKUP_TMP})
+                                                      s.apk_fdroid.TMP_PREFIX})
            for folder, prefix in places:
                folder.mkdir(parents=True, exist_ok=True)
                gone = tempfile.mkdtemp(prefix=f"{prefix}{dead.pid}-", dir=folder)
@@ -1,145 +0,0 @@
-"""Import a local Android backup: one APK and its matching expansion files."""
-import re
-import time
-from pathlib import Path
-
-import frame_android as android
-import frame_quest as quest
-
-OBB = re.compile(r'(main|patch)\.[0-9]+\.([A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)+)\.obb')
-
-
-def inspect(paths, discover=False):
-    """Inspect selected files before installing anything. Desktop APK drops can find
-    sibling OBBs; browser uploads include only files explicitly selected by the user."""
-    if not isinstance(paths, list) or not paths or len(paths) > 100:
-        raise android.FrameError('Choose one game APK and its .obb game-data files together.')
-    files = []
-    for value in paths:
-        path = Path(value).expanduser().absolute()
-        if path.is_dir():
-            files.extend(p for p in sorted(path.iterdir()) if p.suffix.lower() in ('.apk', '.obb'))
-        else:
-            files.append(path)
-    files = list(dict.fromkeys(files))
-    if not files or len(files) > 100:
-        raise android.FrameError('No Android backup found. Choose a folder containing one APK and its game data.')
-    for path in files:
-        if path.suffix.lower() not in ('.apk', '.obb') or not path.is_file() or path.stat().st_size == 0:
-            raise android.FrameError(f'{path.name}: choose a nonempty APK or .obb game-data file.')
-    apks = [p for p in files if p.suffix.lower() == '.apk']
-    if len(apks) > 1:
-        raise android.FrameError('Choose one game at a time. Split APK backups are not supported by this importer.')
-    apk = apks[0] if apks else None
-    if apk:
-        info = android.apk_info(str(apk))
-        try:
-            android.check_installable(info)
-        except android.FrameError as error:
-            error.apk = {'package': info['package'], 'version_code': info.get('version_code'),
-                         'blocker': str(error)}
-            raise
-        checked = quest.inspect(info['package'], str(apk))
-        pkg = checked['package']
-        if discover and len(files) == 1:
-            files.extend(p for p in sorted(apk.parent.iterdir())
-                         if p not in files and OBB.fullmatch(p.name) and OBB.fullmatch(p.name)[2] == pkg)
-    else:
-        packages = {OBB.fullmatch(p.name)[2] for p in files if OBB.fullmatch(p.name)}
-        if len(packages) != 1:
-            raise android.FrameError('Choose the APK and game-data files for one game together.')
-        pkg = packages.pop()
-        if not android.PKG_RE.fullmatch(pkg):
-            raise android.FrameError('The game-data filename has an invalid Android package name.')
-        meta = android.read_meta(pkg)
-        if not meta:
-            raise android.FrameError('This game is not installed. Add its APK alongside these game-data files.')
-        checked = {k: meta.get(k) for k in ('package', 'label', 'version', 'version_code')}
-        checked['version_code'] = quest._installed_code(pkg, meta)
-        if checked['version_code'] is None:
-            raise android.FrameError('Add the matching APK so Frame Control can check which game version this data belongs to.')
-        checked['warnings'] = []
-    obb = [p for p in files if p.suffix.lower() == '.obb']
-    if len(obb) > 99:
-        raise android.FrameError('Choose one APK and at most 99 game-data files.')
-    if obb and checked['version_code'] is None:
-        raise android.FrameError('The APK has no readable version code, so its game-data target cannot be checked.')
-    names = set()
-    for path in obb:
-        match = OBB.fullmatch(path.name)
-        if not match or match[2] != pkg:
-            raise android.FrameError(f'{path.name} does not belong to {checked["label"]}. Choose matching game data.')
-        if not path.is_file() or not path.stat().st_size or path.name in names:
-            raise android.FrameError(f'{path.name}: game-data files must be nonempty and have unique names.')
-        names.add(path.name)
-    return {'apk': apk, 'obb': obb, 'checked': checked,
-            'signatures': {str(p): (p.stat().st_size, p.stat().st_mtime_ns) for p in [*apks, *obb]}}
-
-
-def public(plan):
-    checked = plan['checked']
-    return {**checked, 'apk': plan['apk'].name if plan['apk'] else None,
-            'obb': [{'name': p.name, 'size': p.stat().st_size} for p in plan['obb']],
-            'size': sum(size for size, _ in plan['signatures'].values())}
-
-
-def install(plan, display='auto', progress=None):
-    """The explicit Import button authorizes starting the game to add its data.
-    Reuse the Quest import's instance/version checks, verified transfer and close."""
-    report = progress or (lambda *_: None)
-    if display not in ('auto', 'flat', 'vr'):
-        raise android.FrameError('Invalid Android display mode.')
-    for path, signature in plan['signatures'].items():
-        p = Path(path)
-        if not p.is_file() or (p.stat().st_size, p.stat().st_mtime_ns) != signature:
-            raise android.FrameError('The backup changed after it was read. Choose the files again.')
-    checked = plan['checked']
-    pkg, label = checked['package'], checked['label']
-    with android._install_lock:
-        if plan['apk']:
-            if quest._running(pkg):
-                raise android.FrameError(f'Close {label} on the Frame, then try importing again.')
-            quest._check_downgrade(android.read_meta(pkg), checked, False)
-            report('Installing the game app', 15)
-            meta = android.install(str(plan['apk']), source=plan['apk'].name,
-                                   flatscreen=None if display == 'auto' else display == 'flat')
-        else:
-            meta = android._meta_or_fail(pkg)
-        if not plan['obb']:
-            report('Done', 100)
-            warnings = list(checked['warnings']) + list(meta.get('vr_issues') or [])
-            return {'message': f'Installed {label}. Open it from your Steam library.', 'app': meta,
-                    'needs_game_data': False, 'warnings': warnings}
-        try:
-            if not quest._running(pkg):
-                report('Starting the game to add its data', 55)
-                android.launch(pkg)
-                deadline = time.monotonic() + 90
-                while not quest._running(pkg):
-                    if time.monotonic() >= deadline:
-                        raise android.FrameError('The game did not start. Check that Steam is open on the Frame.')
-                    time.sleep(2)
-            report('Preparing Android for game data', 65)
-            quest._wait_ready(meta)
-            # Android can be booted before Lepton has installed the APK.
-            deadline = time.monotonic() + 90
-            while True:
-                try:
-                    quest._check_android_package(meta, checked['version_code'])
-                    break
-                except quest.QuestError:
-                    if time.monotonic() >= deadline:
-                        raise
-                    time.sleep(2)
-            result = quest.add_game_data(pkg, checked, plan['obb'], None, report,
-                                         checked['warnings'], source='your backup')
-            if result['closed']:
-                result['message'] = (f'Imported {label} and {len(plan["obb"])} game-data '
-                                     f'file{"s" if len(plan["obb"]) != 1 else ""}. '
-                                     'Ready to open from your Steam library.')
-            return result
-        except Exception as error:
-            closed, why = quest._close(pkg)
-            detail = ('The game is closed.' if closed else f'Close the game on the Frame ({why}).')
-            raise android.FrameError(f'{label} is installed, but its game-data setup did not finish: {error}. '
-                                     f'{detail} Import the same backup again to retry.') from error
@@ -558,21 +558,15 @@ class Registry:
        self.config = Path(config) if config else None  # None: ssh_config() at call time
        self.lock = threading.RLock()
        self._depth = 0  # nested _changing() calls
-        self._stamp = None  # devices.json as last loaded or saved
+        self._mtime = None  # devices.json as last loaded or saved
        self.data = {"version": VERSION, "active": None, "devices": [], "networks": {}}
        self.load()

    # -- storage --
-    def _file_stamp(self):
-        stat = self.path.stat()
-        # Saves atomically replace the file. Fast consecutive saves can have the
-        # same timestamp and size; its identity still changes in that case.
-        return stat.st_dev, stat.st_ino, stat.st_mtime_ns, stat.st_size
-
    def load(self):
        with self.lock:
            try:
-                self._stamp = self._file_stamp()
+                self._mtime = self.path.stat().st_mtime_ns
                data = json.loads(self.path.read_text(encoding="utf-8"))
            except (OSError, ValueError):
                return
@@ -613,14 +607,14 @@ class Registry:
            tmp = self.path.with_name(self.path.name + ".tmp")
            tmp.write_text(json.dumps(self.data, indent=1), encoding="utf-8")
            os.replace(tmp, self.path)
-            self._stamp = self._file_stamp()
+            self._mtime = self.path.stat().st_mtime_ns

    def _refresh(self):
        """Pick up what another Frame Control server saved (the app and a standalone
        server can share devices.json)."""
        with self.lock:
            try:
-                if self._file_stamp() != self._stamp:
+                if self.path.stat().st_mtime_ns != self._mtime:
                    self.load()
            except OSError:
                pass
@@ -506,8 +506,10 @@ def apply(gs, event, panel):
        say("ready", focus=panel.get("window"), display=panel.get("display"), stale=True)  # the page re-syncs
        STALE[0] = True
        return panel
-    if STALE[0] and not stale:
+    release = event.get("down") is False and ("button" in event or "key" in event)
+    if STALE[0] and not stale and not (release and "window" not in event):
        # Anything that goes through (a trackpad move names no panel) means caught up: stop re-syncing.
+        # A bare release doesn't: the page leaves the panel off releases, so it says nothing about focus.
        STALE[0] = False
        say("ready", focus=(panel or {}).get("window"), display=(panel or {}).get("display"))
    if "fx" in event and panel and panel.get("window"):
@@ -420,7 +420,7 @@
  .rep-item .s { white-space: normal; }
  #bugDlg, #repDlg, #titleDlg, #wiDlg, #pwDlg, #apkAltDlg, #aboutDlg, #modDlg { background: #1e2329; color: var(--text); border: 1px solid rgba(255,255,255,.1); border-radius: 4px;
            padding: 22px; width: min(560px, 92vw); box-shadow: 0 20px 60px rgba(0,0,0,.6); }
-  #bugDlg::backdrop, #repDlg::backdrop, #titleDlg::backdrop, #wiDlg::backdrop, #pwDlg::backdrop, #apkAltDlg::backdrop, #androidImportDlg::backdrop, #aboutDlg::backdrop, #modDlg::backdrop { background: rgba(0,0,0,.55); }
+  #bugDlg::backdrop, #repDlg::backdrop, #titleDlg::backdrop, #wiDlg::backdrop, #pwDlg::backdrop, #apkAltDlg::backdrop, #aboutDlg::backdrop, #modDlg::backdrop { background: rgba(0,0,0,.55); }
  #bugDlg { width: min(640px, calc(100vw - 40px)); }
  #bugForm label.field { display: block; font-size: 12.5px; color: var(--muted); margin-top: 10px; }
  #bugForm label.field input, #bugForm label.field textarea, #bugForm select { margin-top: 5px; }
@@ -992,8 +992,7 @@
    <div class="shelf-head"><h2>Keyboard and trackpad</h2><span class="sub" id="padState"></span><span class="spacer"></span>
      <button class="small" id="padOn">Turn on</button>
    </div>
-    <p class="sub" id="padIntro">Use this computer's keyboard and mouse in apps on the Frame, such as Chromium or the
-      desktop's Linux apps.</p>
+    <p class="sub" id="padIntro">Use this computer's keyboard and mouse in the panel you're using in the headset.</p>
    <div id="padBody" hidden>
    <div class="pad-area" id="padArea" tabindex="0" role="application" aria-label="Trackpad for the Frame">
      <div class="pad-hint" id="padHint"></div>
@@ -1016,10 +1015,9 @@
        <button data-pad-key="12" title="Enter">Enter</button>
      </span>
    </div>
-    <div class="hint">Types and points in apps on the Frame, such as Chromium or the desktop's Linux apps; Steam's own VR menus
-      don't take it. It works through KDE Connect, which comes with Frame Control: the first time, it copies Valve's build
-      for the Frame (3.6 MB, 18 MB unpacked) into your home folder there and pairs with it. No internet needed, and nothing
-      else to install. <a href="#" data-about>Licences</a></div>
+    <div class="hint">Types and points in whichever panel has focus in the headset, through Valve's own input path: nothing to
+      install and no internet needed. Accents and emoji go through KDE Connect, which comes with Frame Control and starts
+      the first time you type one (it copies Valve's build for the Frame, 3.6 MB, into your home folder there). <a href="#" data-about>Licences</a></div>
    </div>
  </section>

@@ -1088,7 +1086,7 @@
  <section id="android">
    <div class="store-tabs" aria-label="Android sections"><button class="on" data-store-tab="browse" aria-pressed="true">Discover</button><button data-store-tab="library" aria-pressed="false">On your Frame <span id="andCount"></span></button><span class="spacer"></span><button id="sourcesOpen" class="small" title="Choose where Discover looks for apps">Sources…</button><button class="small" id="repNew" hidden>+ Report an APK</button></div>
    <section id="appStore" aria-label="Discover apps">
-      <div class="store-toolbar"><div class="store-heading"><div><h1>Apps and games for the Frame</h1><p>Free Android apps and VR games from open app stores and developers' own pages, each marked with whether it runs on the Frame. Steam games are in <a href="#games">Games</a>.</p><button class="small" id="androidBackupOpen">Import game files…</button></div></div>
+      <div class="store-toolbar"><div class="store-heading"><div><h1>Apps and games for the Frame</h1><p>Free Android apps and VR games from open app stores and developers' own pages, each marked with whether it runs on the Frame. Steam games are in <a href="#games">Games</a>.</p></div></div>
      <form id="sourceSearch" class="store-search"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" aria-hidden="true"><circle cx="10.5" cy="10.5" r="6.5"/><path d="m16 16 5 5"/></svg><input id="sourceQ" type="search" aria-label="Search games and apps" placeholder="Search games and apps"><button type="submit" class="small">Search</button></form></div>
      <div class="store-filters"><div id="searchFilters" class="store-chips"><button data-filter="all" aria-pressed="true">All</button><button data-filter="vr" aria-pressed="false">VR</button><button data-filter="flat" aria-pressed="false">Flat-screen</button><button data-filter="installable" aria-pressed="false">Installs on the Frame</button></div></div>
      <div id="sourceStatus" class="store-notice" role="status" aria-live="polite" hidden></div>
@@ -1110,14 +1108,6 @@
        <div class="hint">Games from the store, your Quest and your Meta library install one after another.
          Remove takes a game out before it starts.</div>
      </section>
-      <section class="panel" id="androidBackup">
-        <div class="shelf-head"><h2>Import Android game</h2></div>
-        <p class="sub">Have a SideQuest backup? Choose the game's APK and all its .obb game-data files together.
-          Frame Control installs the app and puts its data in the right place.</p>
-        <button class="action small" id="androidBackupChoose">Choose game files…</button>
-        <input type="file" id="androidBackupInput" accept=".apk,.obb" multiple hidden>
-        <p class="hint desk-only">In the desktop app, drop the backup folder or its APK. Matching game data in the same folder is found automatically.</p>
-      </section>
      <section class="panel" id="quest">
        <div class="shelf-head"><h2>Import from my Quest</h2><span class="count" id="questCount"></span><span class="spacer"></span>
          <button class="small" id="questScan" title="Look for a Meta Quest plugged into this computer by USB">Look for my Quest</button></div>
@@ -1290,8 +1280,7 @@
      <div class="shelf-head"><h2>Send to Frame</h2></div>
      <div class="drop" id="drop" tabindex="0" role="button" aria-label="Choose files to send">
        <b><span class="desk-only">Drop files here, or click to choose</span><span class="mobile-only">Tap to choose files</span></b>
-        Android backups: choose the <code>.apk</code> and its <code>.obb</code> game data together.
-        Other files land in <code>~/Downloads</code>;
+        Files land in <code>~/Downloads</code>. <code>.apk</code> files install as their own Android app;
        a game's <code>.zip</code>, folder or <code>.exe</code> becomes a title in the Steam library.
        <span class="desk-only">You can also drop files anywhere in this window.</span>
        <input type="file" id="fileInput" multiple hidden>
@@ -1421,8 +1410,7 @@
 </main>
 </div>
 <div class="dropzone" id="dropzone" hidden><div><b>Drop to send to the Frame</b>
-  <span class="sub">Android backups: drop the <code>.apk</code> and its <code>.obb</code> game data together.
-  Other files go to <code>~/Downloads</code>;
+  <span class="sub">Files go to <code>~/Downloads</code>; <code>.apk</code> files install as Android apps;
  a game's <code>.zip</code>, folder or <code>.exe</code> becomes a Steam library title.</span></div></div>

 <div class="drawer" id="drawer"><div class="log" id="log"></div></div>
@@ -1444,19 +1432,6 @@
  <p id="sourceError" class="store-notice" role="status" aria-live="polite"></p>
 </dialog>

-<dialog id="androidImportDlg" aria-labelledby="androidImportTitle" style="background:#1e2329;color:var(--text);border:1px solid var(--muted);border-radius:4px;padding:24px;width:480px;max-width:calc(100vw - 32px)">
-  <h2 id="androidImportTitle" style="margin-top:0">Import Android game</h2>
-  <p id="androidImportName"></p>
-  <div id="androidImportFiles" class="list" style="overflow-wrap:anywhere"></div>
-  <p class="sub" id="androidImportNote"></p>
-  <p class="sub" id="androidImportWarnings"></p>
-  <p id="androidImportState" role="status" aria-live="polite"></p>
-  <progress id="androidImportProgress" max="100" hidden style="width:100%" aria-label="Game import progress"></progress>
-  <div class="actions">
-    <button id="androidImportCancel">Cancel</button>
-    <button id="androidImportGo" class="action">Import game</button>
-  </div>
-</dialog>
 <dialog id="apkAltDlg" aria-labelledby="apkAltTitle">
  <h2 id="apkAltTitle">Try another APK version</h2>
  <p id="apkAltReason"></p>
@@ -1761,7 +1736,6 @@ async function api(path, body, device = window.connDevice) {
  checkGeneration();
  if (!r.ok) {
    const err = new Error(data.error || `HTTP ${r.status}`);
-    err.apk = data.apk;
    err.offline = !!data.offline;
    if (err.offline) setOnline(false, err.message);
    throw err;
@@ -3049,25 +3023,20 @@ window.addEventListener("drop", e => {
  const dirs = new Set(items.map((it, i) => it.webkitGetAsEntry && it.webkitGetAsEntry()?.isDirectory ? i : -1).filter(i => i >= 0));
  sendFiles([...e.dataTransfer.files], dirs);
 });
-function upload(file, mode, dev = window.connDevice, backupToken = null, progress = () => {}, signal = null) {
+function upload(file, mode, dev = window.connDevice) {
  return new Promise((resolve, reject) => {
-    if (signal?.aborted) return reject(new Error("Import cancelled"));
    const xhr = new XMLHttpRequest();
-    const abort = () => xhr.abort();
-    const cleanup = () => signal?.removeEventListener("abort", abort);
    xhr.open("POST", "/api/upload");
    xhr.setRequestHeader("X-Frame-UI", UI_KEY);
    if (dev) xhr.setRequestHeader("X-Frame-Device", dev);
    xhr.setRequestHeader("X-Filename", encodeURIComponent(file.name));
    xhr.setRequestHeader("X-Mode", mode);
-    if (backupToken) xhr.setRequestHeader("X-Android-Backup", backupToken);
    if (mode === "apk") xhr.setRequestHeader("X-APK-Display", $("apkDisplay").value);
    const bar = $("prog").firstElementChild;
    $("prog").style.display = "block"; bar.style.width = "0";
-    xhr.upload.onprogress = e => { if (e.lengthComputable) { bar.style.width = (100 * e.loaded / e.total) + "%"; progress(100 * e.loaded / e.total); } };
+    xhr.upload.onprogress = e => { if (e.lengthComputable) bar.style.width = (100 * e.loaded / e.total) + "%"; };
    const gen = devGen;
    xhr.onload = () => {
-      cleanup();
      $("prog").style.display = "none";
      let data; try { data = JSON.parse(xhr.responseText); } catch { data = { error: `HTTP ${xhr.status}` }; }
      if (gen !== devGen) {  // the app switched headsets meanwhile: nothing to offer about this one here
@@ -3078,9 +3047,7 @@ function upload(file, mode, dev = window.connDevice, backupToken = null, progres
      if (data.apk?.blocker && xhr.status >= 300) checkApkAlternatives(data.apk, dev);
      xhr.status < 300 ? resolve(data) : reject(new Error(data.error));
    };
-    xhr.onerror = () => { cleanup(); $("prog").style.display = "none"; reject(new Error("network error")); };
-    xhr.onabort = () => { cleanup(); $("prog").style.display = "none"; reject(new Error("Import cancelled")); };
-    signal?.addEventListener("abort", abort, {once:true});
+    xhr.onerror = () => { $("prog").style.display = "none"; reject(new Error("network error")); };
    xhr.send(file);
  });
 }
@@ -3181,135 +3148,29 @@ document.addEventListener("click", async e => {
 $("aboutClose").onclick = () => $("aboutDlg").close();

 const TITLE_EXT = /\.(zip|exe)$/i;
-let fileSendQueue = Promise.resolve();
-function sendFiles(files, dirs = new Set()) {
-  const dev = window.connDevice;
-  const run = fileSendQueue.then(() => sendFilesOne(files, dirs, dev));
-  fileSendQueue = run.catch(e => toast(e.message, true));
-  return fileSendQueue;
-}
-async function sendFilesOne(files, dirs, dev) {
-  const androidFiles = files.filter((f, i) => !dirs.has(i) && /\.(apk|obb)$/i.test(f.name));
-  const grouped = androidFiles.some(f => /\.obb$/i.test(f.name));
-  if (grouped && window.connDevice === dev) await importAndroidFiles(androidFiles, dev);
+async function sendFiles(files, dirs = new Set()) {
+  const dev = window.connDevice;  // the whole batch is for the headset it was dropped on
  for (const [i, f] of files.entries()) {
    if (window.connDevice !== dev) {
      toast(`Switched headsets: didn't send ${files.length - i} remaining file${files.length - i === 1 ? "" : "s"}`, true);
      break;
    }
-    if (grouped && androidFiles.includes(f)) continue;
    const path = window.frameApp?.pathForFile ? window.frameApp.pathForFile(f) : "";
    if (dirs.has(i)) {
-      if (path) {
-        if (!await importAndroidFiles([f], dev, true)) await sideload(f, path, true);
-      }
+      if (path) await sideload(f, path, true);
      else toast(`${f.name}: zip the folder first (folders need the Frame Control app)`, true);
      continue;
    }
    if (!f.size) { toast(`${f.name}: empty files aren't supported`, true); continue; }
    if (TITLE_EXT.test(f.name)) { await sideload(f, path); continue; }
    const apk = f.name.toLowerCase().endsWith(".apk");
-    if (apk) await importAndroidFiles([f], dev);
-    else await act(`Copy ${f.name} to ~/Downloads`, () => upload(f, "push", dev));
+    const res = await act(apk ? `Install ${f.name}` : `Copy ${f.name} to ~/Downloads`, () => upload(f, apk ? "apk" : "push", dev));
+    if (apk && res && res.app) await offerTest(res.app);
  }
  $("fileInput").value = "";
  refresh();
 }

-$("androidBackupChoose").onclick = () => $("androidBackupInput").click();
-$("androidBackupOpen").onclick = () => $("androidBackupInput").click();
-$("androidBackupInput").onchange = () => {
-  sendFiles([...$("androidBackupInput").files]);
-  $("androidBackupInput").value = "";
-};
-async function importAndroidFiles(files, dev, probe = false) {
-  const dlg = $("androidImportDlg");
-  let token = null, running = false;
-  const controller = new AbortController();
-  const finished = new Promise(resolve => dlg.addEventListener("close", () => { controller.abort(); resolve(); }, {once:true}));
-  $("androidImportName").textContent = "Reading your backup…";
-  for (const id of ["androidImportFiles", "androidImportNote", "androidImportWarnings", "androidImportState"]) $(id).textContent = "";
-  $("androidImportGo").hidden = false;
-  $("androidImportGo").disabled = true;
-  $("androidImportGo").textContent = "Import game";
-  $("androidImportCancel").disabled = false;
-  $("androidImportCancel").textContent = "Cancel";
-  $("androidImportCancel").onclick = () => dlg.close();
-  dlg.oncancel = e => { if (running) e.preventDefault(); };
-  $("androidImportProgress").hidden = true;
-  dlg.showModal();
-  try {
-    let read;
-    const paths = files.map(f => window.frameApp?.pathForFile?.(f) || "");
-    if (paths.every(Boolean)) {
-      read = await api("/api/android/backup", {action:"inspect", paths, probe}, dev);
-      if (read.android === false) { dlg.close(); await finished; return false; }
-      token = read.token;
-    } else {
-      token = (await api("/api/android/backup", {action:"begin"}, dev)).token;
-      for (const [i, file] of files.entries()) {
-        if (!dlg.open) return true;
-        $("androidImportState").textContent = `Reading file ${i + 1} of ${files.length}: ${file.name}`;
-        $("androidImportProgress").hidden = false;
-        await upload(file, "android-backup", dev, token, percent => { $("androidImportProgress").value = percent; }, controller.signal);
-      }
-      read = await api("/api/android/backup", {action:"inspect", token}, dev);
-    }
-    if (!dlg.open) return true;
-    const plan = read.plan;
-    $("androidImportName").textContent = `${plan.label}${plan.version ? " · " + plan.version : ""}`;
-    $("androidImportFiles").innerHTML = (plan.apk ? `<div class="sub">Game app</div><div>${esc(plan.apk)}</div>`
-      : `<div class="sub">Game app already installed</div>`) +
-      `<div class="sub" style="margin-top:12px">Game data · ${plan.obb.length} file${plan.obb.length === 1 ? "" : "s"}</div>` +
-      plan.obb.map(f => `<div>${esc(f.name)} <span class="sub">${gb(f.size)}</span></div>`).join("");
-    $("androidImportNote").textContent = plan.obb.length
-      ? "Frame Control will start the game, copy its data to the right place, and close it. Then you can open it from your Steam library."
-      : "No game-data files selected. If your backup includes .obb files, cancel and choose them with the APK. In the desktop app, matching files beside the APK are found automatically.";
-    $("androidImportWarnings").textContent = (plan.warnings || []).join(" ");
-    $("androidImportState").textContent = "";
-    $("androidImportProgress").hidden = true;
-    $("androidImportGo").textContent = plan.obb.length ? "Import game & data" : "Install game app";
-    $("androidImportGo").disabled = false;
-    const chosen = await Promise.race([
-      new Promise(resolve => { $("androidImportGo").onclick = () => resolve(true); }),
-      finished.then(() => false),
-    ]);
-    if (!chosen) return true;
-    if (window.connDevice !== dev) throw new Error("The headset changed. Choose the backup again for this Frame.");
-    running = true;
-    $("androidImportCancel").disabled = true;
-    $("androidImportGo").disabled = true;
-    $("androidImportProgress").hidden = false;
-    $("androidImportProgress").value = 0;
-    const result = await runJob(`Import ${plan.label}`, `backup:${token}`, async () => {
-      try {
-        const started = await api("/api/android/backup", {action:"install", token, display:$("apkDisplay").value}, dev);
-        token = null;  // the job owns the uploaded files now
-        return started;
-      } catch (e) { $("androidImportState").textContent = e.message; throw e; }
-    }, j => {
-      $("androidImportState").textContent = j.error || j.message || j.stage || "Importing…";
-      if (j.percent != null) $("androidImportProgress").value = j.percent;
-    });
-    $("androidImportState").textContent = result?.message || $("androidImportState").textContent || "Setup did not finish. Import the backup again to retry.";
-    if (result?.warnings?.length) $("androidImportWarnings").textContent = result.warnings.join(" ");
-  } catch (e) {
-    if (controller.signal.aborted) return true;
-    $("androidImportState").textContent = e.message;
-    log(`Import Android game: ${e.message}`, "e");
-    if (e.apk?.blocker) { dlg.close(); checkApkAlternatives(e.apk, dev); }
-  } finally {
-    running = false;
-    $("androidImportProgress").hidden = true;
-    $("androidImportGo").hidden = true;
-    $("androidImportCancel").disabled = false;
-    $("androidImportCancel").textContent = "Close";
-    if (token) api("/api/android/backup", {action:"discard", token}, dev).catch(() => {});
-  }
-  await finished;
-  return true;
-}
-
 // ---- sideloaded titles (a Linux or Windows build as a Steam Devkit Game) ----
 const RESERVED_IDS = ["steam", "steamdeckard", "steamvr", "steamvrdeckard", "devkit-steam"];
 function titleId(name) {  // mirrors frame_titles.title_id: the name Steam shows
@@ -4772,10 +4633,10 @@ const typesText = el => el?.matches?.('textarea, input:not([type=range], [type=c
 document.addEventListener("focusin", e => document.body.classList.toggle("typing", !!typesText(e.target)));
 document.addEventListener("focusout", () => document.body.classList.remove("typing"));

-// ---- keyboard and trackpad: events go to KDE Connect on the Frame (see ui/frame_input_agent.py) ----
+// ---- keyboard and trackpad: events go to the Frame through gamescope (ui/frame_touch.py); accents and emoji through KDE Connect ----
 const pad = { state: "off", queue: [], sending: false, poll: null, captured: false };
 const PAD_STATES = {
-  off: "", starting: "Connecting…", installing: "Setting up KDE Connect on the Frame (first time only)…",
+  off: "", starting: "Connecting…", installing: "Setting up (first time only)…",
  pairing: "Pairing with KDE Connect…", ready: "On",
 };
 // KDE Connect's specialKey numbers (plugins/mousepad in its source).
@@ -4795,7 +4656,7 @@ function padShow(status) {
  $("padArea").classList.toggle("off", !ready);
  $("padBody").hidden = pad.state === "off";
  $("padIntro").hidden = pad.state !== "off";
-  $("padHint").textContent = pad.state === "error" ? status.message || "Couldn't reach KDE Connect on the Frame."
+  $("padHint").textContent = pad.state === "error" ? status.message || "Couldn't reach the Frame."
    : !ready ? (busy ? PAD_STATES[pad.state] : "Turn on to use this as a trackpad for the Frame.")
    : TOUCH ? "Drag to move the pointer · tap to click · two fingers to scroll · two-finger tap to right-click"
    : pad.captured ? "Your mouse and keyboard now control the Frame. Press Esc to stop."
@@ -44,7 +44,6 @@ sys.path.insert(0, str(Path(__file__).resolve().parent))
 import frame_agent  # noqa: E402
 import frame_assistant  # noqa: E402
 import frame_android  # noqa: E402
-import frame_android_import  # noqa: E402
 from apk_sources import search as apk_search, SourceError  # noqa: E402
 from apk_sources import fdroid as apk_fdroid  # noqa: E402
 import frame_apk_versions  # noqa: E402
@@ -64,6 +63,7 @@ import frame_report  # noqa: E402
 import frame_store  # noqa: E402
 import frame_telemetry  # noqa: E402
 import frame_titles  # noqa: E402
+import frame_touch  # noqa: E402
 import frame_webinstall  # noqa: E402
 import frame_vr  # noqa: E402
 import frame_utilities  # noqa: E402
@@ -116,6 +116,9 @@ def route(alias, host_opts):
    with _route_lock:
        moved = alias != FRAME
        if moved:
+            reset_pad = globals().get("reset_pad_route")
+            if reset_pad:
+                reset_pad()  # cancel old input before any agent can start on the new route
            frame_catalog._env.clear()  # the SteamOS and Lepton builds reports record are per headset
        FRAME = frame_android.FRAME = alias
        HOST_OPTS = list(host_opts)
@@ -126,9 +129,6 @@ def route(alias, host_opts):
    mv = globals().get("macview")
    if mv:
        mv.retarget(alias, host_opts)  # its tunnel is its own ssh: it must follow the headset too
-    agent = globals().get("_input")
-    if moved and agent:
-        agent.stop()  # typing and pointing mustn't go on reaching the headset switched away from


 LINK = None  # the connector (frame_link.Link); None on the Frame itself
@@ -1169,12 +1169,192 @@ def licenses():
    return notices


+# KDE Connect's specialKey numbers -> Linux key codes (KEY_BACKSPACE, KEY_TAB, ...).
+PAD_KEYS = {1: 14, 2: 15, 4: 105, 5: 103, 6: 106, 7: 108, 8: 104, 9: 109, 10: 102, 11: 107, 12: 28, 13: 111, 14: 1,
+            **{21 + i: code for i, code in enumerate([59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 87, 88])}}
+PAD_MODS = (("ctrl", 29), ("alt", 56), ("shift", 42), ("super", 125))
+PAD_CLICKS = {"singleclick": "left", "rightclick": "right", "middleclick": "middle"}
+PAD_NOTCH = 15  # scroll units for one wheel notch
+
+
+def typed_in_kde(events):
+    """Whether these events must go the KDE Connect way: they hold an accent or emoji, or
+    earlier ones are queued, being sent or still being typed there (typing must stay in
+    order, so it can't be split between the two ways)."""
+    with _kde_lock:
+        waiting = bool(_kde_queue) or time.time() < _kde_until
+    return waiting or any(ch not in frame_touch.ASCII for e in events for ch in e.get("key", ""))
+
+
+def pad_events(events, kde=False):
+    """The trackpad's and key row's events as (gamescope events, KDE Connect events).
+
+    Gamescope's own input reaches every panel and needs nothing installed, but types only
+    US-keyboard characters. With kde, the keyboard goes to KDE Connect as it was sent, so
+    text stays in order; the pointer always goes through gamescope.
+    """
+    ascii_keys = frame_touch.ASCII
+    out, slow = [], []
+
+    def tap(code, mods):
+        down = [{"key": c, "down": True} for c in mods]
+        out.extend(down + [{"key": code, "down": True}, {"key": code, "down": False}]
+                   + [{"key": c, "down": False} for c in reversed(mods)])
+    for e in events:
+        mods = [code for name, code in PAD_MODS if e.get(name)]
+        if "dx" in e or "dy" in e:
+            if not e.get("scroll"):
+                out.append({k: e[k] for k in ("dx", "dy") if k in e})
+        if e.get("scroll"):
+            out.append({"scroll": [0, -(e.get("dy") or 0) * PAD_NOTCH]})
+        for flag, button in PAD_CLICKS.items():
+            if e.get(flag):
+                out += [{"button": button, "down": True}, {"button": button, "down": False}]
+        if e.get("doubleclick"):
+            out += [{"button": "left", "down": d} for d in (True, False, True, False)]
+        if e.get("singlehold"):
+            out.append({"button": "left", "down": True})
+        if e.get("singlerelease"):
+            out.append({"button": "left", "down": False})
+        if kde and ("key" in e or "specialKey" in e):
+            slow.append({k: e[k] for k in ("key", "specialKey", "ctrl", "alt", "shift", "super") if k in e})
+            continue
+        if "specialKey" in e and e["specialKey"] in PAD_KEYS:
+            tap(PAD_KEYS[e["specialKey"]], mods)
+        if "key" in e:
+            for ch in e["key"]:
+                if ch not in ascii_keys:
+                    continue  # only reached when kde is wrong; the caller checks typed_in_kde first
+                elif mods:
+                    code, shifted = ascii_keys[ch]
+                    tap(code, mods + ([42] if shifted and 42 not in mods else []))
+                else:
+                    if out and "text" in out[-1] and len(out[-1]["text"]) < 100:
+                        out[-1]["text"] += ch
+                    else:
+                        out.append({"text": ch})
+    return out, slow
+
+
 def remote_input(body):
-    """{"events": [...]} sends keyboard and pointer events; {} (or none yet) just starts the agent."""
+    """{"events": [...]} sends keyboard and pointer events; {} (or none yet) just starts the agent.
+
+    "sent" in the answer means the whole batch is taken (the page keeps it and tries again
+    if not), so the keyboard's share is queued only once that's so.
+    """
    events = body.get("events", [])
    if not isinstance(events, list) or len(events) > INPUT_BATCH_LIMIT:
        raise Failure(f"events must be a list of at most {INPUT_BATCH_LIMIT}", 400)
-    return _input.send([input_event(e) for e in events])
+    events = [input_event(e) for e in events]
+    touch, slow = pad_events(events, typed_in_kde(events))
+    status = _touch.send(touch)
+    if touch and not status.get("sent"):
+        return status
+    if touch:
+        _note_typed(touch)
+    if slow:
+        _queue_for_kde(slow)
+    return {**status, "sent": True}
+
+
+# Typing KDE Connect is to do: it starts the first time it's needed, so this waits for it.
+# Nothing on the Frame says when typed text has landed, so each way holds the other back
+# for as long as what it was given should take (a short margin on a time estimate).
+_kde_queue = []
+_kde_lock = threading.Lock()
+_pad_send_lock = threading.Lock()
+_kde_worker = [None]
+_kde_until = 0.0     # keys typed through KDE Connect should have landed by then
+_typed_until = 0.0   # when gamescope's agent will have typed everything it's been given
+_kde_route = object()
+_kde_cancel = threading.Event()
+KDE_QUEUE_LIMIT = 200
+KDE_WAIT = 90  # seconds to wait for KDE Connect before giving up on what's queued
+TYPING_SETTLE = 0.6  # seconds past the estimate, once
+
+
+def reset_pad_route():
+    """Discard input for the headset being left, including batches waiting for an agent."""
+    global _kde_route, _kde_cancel, _kde_until, _typed_until
+    with _pad_send_lock, _kde_lock:
+        _kde_cancel.set()
+        _kde_cancel = threading.Event()
+        _kde_route = object()
+        _kde_queue.clear()
+        _kde_worker[0] = None
+        _kde_until = _typed_until = 0.0
+        _input.stop()
+        _touch.stop()
+
+
+def typing_seconds(touch):
+    """How long gamescope's agent takes over these: it sleeps 8 ms after every key transition."""
+    transitions = 0
+    for e in touch:
+        if "text" in e:
+            transitions += sum(2 + 2 * frame_touch.ASCII[ch][1] for ch in e["text"] if ch in frame_touch.ASCII)
+        elif "key" in e:
+            transitions += 1
+    return transitions * 0.008
+
+
+def _note_typed(touch):
+    global _typed_until
+    seconds = typing_seconds(touch)
+    if seconds:
+        with _kde_lock:  # the end of the work, which queues up; the margin is added once, where it's checked
+            _typed_until = max(_typed_until, time.time()) + seconds
+
+
+def _queue_for_kde(events):
+    with _kde_lock:
+        _kde_queue.extend(events)
+        del _kde_queue[:-KDE_QUEUE_LIMIT]
+        if _kde_worker[0] is None:
+            _kde_worker[0] = threading.Thread(target=_drain_kde, args=(_kde_route, _kde_cancel), daemon=True)
+            _kde_worker[0].start()
+
+
+def _drain_kde(route, cancel):
+    """The only sender, in order. A batch leaves the queue while it's being sent (the queue
+    can be trimmed meanwhile) and goes back to the front if it didn't go."""
+    global _kde_until
+    deadline = time.time() + KDE_WAIT
+    while True:
+        with _kde_lock:
+            if route is not _kde_route:
+                return
+            batch = _kde_queue[:INPUT_BATCH_LIMIT]
+            del _kde_queue[:len(batch)]
+            if not batch:
+                _kde_worker[0] = None  # retired under the lock, so a new request starts another
+                return
+            wait = _typed_until + TYPING_SETTLE - time.time()
+            _kde_until = time.time() + 3600  # held while in flight
+        if wait > 0 and cancel.wait(wait):
+            return  # a switch cancels the delay and its old-headset batch
+        # Serialize sending with route resets without blocking callers from queuing input.
+        with _pad_send_lock:
+            with _kde_lock:
+                if route is not _kde_route:
+                    return
+            status = _input.send(batch)
+        with _kde_lock:
+            if route is not _kde_route:
+                return
+            if status.get("sent"):
+                _kde_until = time.time() + len(batch) * 0.03 + TYPING_SETTLE
+                deadline = time.time() + KDE_WAIT
+                continue
+            _kde_until = 0.0
+            if status.get("state") == "error" or time.time() > deadline:
+                _kde_queue.clear()  # not coming; don't hold it forever
+                _kde_worker[0] = None
+                return
+            _kde_queue[:0] = batch
+            del _kde_queue[:-KDE_QUEUE_LIMIT]  # as when queuing: the oldest go first
+        if cancel.wait(0.4):
+            return


 # ---- touch: the headset's panels, through gamescope's own input (frame_touch.py) ----
@@ -1598,93 +1778,6 @@ def apk_installed(info, meta, error, seconds):
 frame_android.install_hooks.append(apk_installed)


-# ---- Local Android backups (one APK and its OBB game data) ---------------
-
-_android_backups = {}
-_android_backups_lock = threading.Lock()
-ANDROID_BACKUP_TMP = 'frame-android-backup-'
-
-
-def _discard_android_backup(entry):
-    for folder in entry['dirs']:
-        shutil.rmtree(folder, ignore_errors=True)
-
-
-def _android_backup(token=None):
-    now = time.time()
-    with _android_backups_lock:
-        stale = [_android_backups.pop(t) for t, e in list(_android_backups.items())
-                 if now - e['time'] > 3600]
-        entry = _android_backups.get(token)
-    for old in stale:
-        _discard_android_backup(old)
-    if not entry:
-        raise Failure('This import expired. Choose the backup files again.', 400)
-    device = LINK.active_device()['id'] if LINK else None
-    if entry['device'] != device:
-        raise Failure('The headset changed. Choose the backup files again for this Frame.', 409)
-    entry['time'] = now
-    return entry
-
-
-def android_backup(body):
-    action = body.get('action')
-    if action == 'begin' or (action == 'inspect' and 'paths' in body):
-        paths = body.get('paths', [])
-        if not isinstance(paths, list) or len(paths) > 100 or any(
-                not isinstance(p, str) or not os.path.isabs(p) for p in paths):
-            raise Failure('Choose local Android backup files.', 400)
-        # A dropped PC-game folder continues through the existing title importer.
-        if body.get('probe') and len(paths) == 1 and Path(paths[0]).is_dir():
-            if not any(p.suffix.lower() in ('.apk', '.obb') for p in Path(paths[0]).iterdir()):
-                return {'android': False}
-        token = secrets.token_hex(12)
-        entry = {'paths': paths, 'dirs': [], 'plan': None, 'time': time.time(),
-                 'device': LINK.active_device()['id'] if LINK else None}
-        with _android_backups_lock:
-            _android_backups[token] = entry
-        _android_backup(token)  # also expire abandoned imports
-        if action == 'begin':
-            return {'token': token}
-    else:
-        token = str(body.get('token') or '')
-        entry = _android_backup(token)
-    if action == 'inspect':
-        try:
-            entry['plan'] = frame_android_import.inspect(entry['paths'], discover=not entry['dirs'])
-        except (frame_android.FrameError, OSError) as error:
-            with _android_backups_lock:
-                _android_backups.pop(token, None)
-            _discard_android_backup(entry)
-            raise Failure(str(error), 400, getattr(error, 'apk', None))
-        return {'android': True, 'token': token, 'plan': frame_android_import.public(entry['plan'])}
-    if action not in ('install', 'discard'):
-        raise Failure('Unknown Android backup action.', 400)
-    if action == 'install' and not entry['plan']:
-        raise Failure('Read the backup before importing it.', 400)
-    display = body.get('display', 'auto')
-    if display not in ('auto', 'flat', 'vr'):
-        raise Failure('Invalid Android display mode.', 400)
-    with _android_backups_lock:
-        if _android_backups.pop(token, None) is not entry:
-            raise Failure('This import was already started or cancelled. Choose the files again.', 409)
-    if action == 'discard':
-        _discard_android_backup(entry)
-        return {'message': 'Import cancelled'}
-
-    def work(report):
-        try:
-            return frame_android_import.install(entry['plan'], display, report)
-        finally:
-            _discard_android_backup(entry)
-    try:
-        ensure_master()
-        return start_job('Import ' + entry['plan']['checked']['label'], work, progress=True)
-    except BaseException:
-        _discard_android_backup(entry)
-        raise
-
-
 # ---- Sideloaded titles (Linux/Windows builds as Steam Devkit Games) --------
 #
 # Installing is two steps: inspect (a dropped file is uploaded and a zip
@@ -2300,7 +2393,7 @@ def _pid_alive(pid):
 def _tmp_places():
    """Where each kind of staging folder goes, and its name before the server's PID."""
    tmp = Path(tempfile.gettempdir())
-    return [(tmp, WEB_TMP_PREFIX), (tmp, ANDROID_BACKUP_TMP), (tmp, frame_titles.TMP_PREFIX), (tmp, frame_android.TMP_PREFIX),
+    return [(tmp, WEB_TMP_PREFIX), (tmp, frame_titles.TMP_PREFIX), (tmp, frame_android.TMP_PREFIX),
            (tmp, frame_agent.TMP_PREFIX), (frame_host.cache_dir("apk-sources"), apk_fdroid.TMP_PREFIX)]


@@ -2587,7 +2680,6 @@ def source_manage(body):


 POST = {
-    "/api/android/backup": android_backup,
    "/api/vr": vr,
    "/api/comfort": comfort, "/api/media": media, "/api/agent/call": agent_call,
    "/api/agent/approval": agent_approval, "/api/assistant/chat": assistant_chat,
@@ -2834,7 +2926,7 @@ class Handler(BaseHTTPRequestHandler):
            elif path == "/api/touch":
                self.send_json(_touch.send([]) if parse_qs(url.query).get("start") == ["1"] else dict(_touch.status))
            elif path == "/api/input":
-                self.send_json(_input.send([]) if parse_qs(url.query).get("start") == ["1"] else dict(_input.status))
+                self.send_json(_touch.send([]) if parse_qs(url.query).get("start") == ["1"] else dict(_touch.status))
            elif path == "/api/job":
                self.send_json(job_status(url.query))
            elif path == "/api/queue":
@@ -3026,14 +3118,7 @@ class Handler(BaseHTTPRequestHandler):
            raise Failure("empty or too-large upload", 400)
        if mode in ("apk", "apkinfo") and not name.lower().endswith(".apk"):
            raise Failure("APK install needs a .apk file", 400)
-        backup = None
-        if mode == 'android-backup':
-            backup = _android_backup(self.headers.get('X-Android-Backup'))
-            if (not name.lower().endswith(('.apk', '.obb')) or '/' in name or '\\' in name
-                    or len(backup['paths']) >= 100 or any(Path(p).name == name for p in backup['paths'])):
-                raise Failure('Choose one APK and its game data, with no duplicate filenames.', 400)
-        prefix = f'{ANDROID_BACKUP_TMP}{os.getpid()}-' if backup is not None else 'frame-ui-'
-        tmp = Path(tempfile.mkdtemp(prefix=prefix))
+        tmp = Path(tempfile.mkdtemp(prefix="frame-ui-"))
        keep = False
        try:
            dest = tmp / name
@@ -3045,16 +3130,6 @@ class Handler(BaseHTTPRequestHandler):
                        raise Failure("upload interrupted", 400)
                    f.write(chunk)
                    remaining -= len(chunk)
-            if backup is not None:
-                with _android_backups_lock:
-                    if _android_backups.get(self.headers.get('X-Android-Backup')) is not backup:
-                        raise Failure('This import was cancelled. Choose the backup files again.', 400)
-                    backup['paths'].append(str(dest))
-                    backup['dirs'].append(str(tmp))
-                    backup['plan'] = None
-                    backup['time'] = time.time()
-                keep = True
-                return {'message': f'Read {name}', 'token': self.headers.get('X-Android-Backup')}
            if mode == "media":
                return push_media(dest)
            if mode == "apkinfo":
Author	SHA1	Message	Date
SAPHID	cba23fb3af	fix(ui): reconcile PR 66 with current main	2026-10-18 00:37:13 +00:00
SAPHID	62b3cbf705	fix(input): cancel old headset input when switching routes	2026-10-17 23:55:09 +00:00
saphidandClaude Sonnet 5.5	024ec593f9	Merge origin/main into pad-gamescope Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>	2026-10-01 21:06:06 +10:00
saphidandClaude Sonnet 5.5	0373555519	Pad: count gamescope's real typing time, with the settle margin added once Review found the estimate used 12 ms a character where the agent takes 16 ms (32 shifted), and added the margin on every request so it piled up. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>	2026-10-01 21:01:53 +10:00
saphidandClaude Sonnet 5.5	3539215517	Pad: drain the KDE Connect queue without losing, stranding or reordering input Second review found the queue could be trimmed under an in-flight send (deleting unsent events), the worker could retire as a request enqueued, and ASCII could overtake an accent still being typed (or the reverse). The worker now takes its batch out while sending and puts it back on failure, retires under the lock, and each way waits out the other's estimated typing time. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>	2026-10-01 20:57:08 +10:00
saphidandClaude Sonnet 5.5	9f3fb89e30	Pad: keep typing in order and acknowledge it once, with accents through one KDE Connect queue Review found accent-only input repeated forever (sent was false), text split across two transports out of order, accents stuck until the next keypress, duplicated on retry, and racy. A batch with an accent now sends its whole keyboard through KDE Connect; later keys follow while any are queued; the server owns one ordered, bounded queue drained by a single thread; sent means the whole batch is taken. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>	2026-10-01 20:52:41 +10:00
saphidandClaude Sonnet 5.5	dc7854d10b	Touch: a bare release no longer clears the stale-focus notice before the page has seen it The page leaves the panel off releases, so a release says nothing about focus. Found in review of the stale-latch fix. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>	2026-10-01 20:52:41 +10:00
saphidandClaude Sonnet 5.5	5a6b925448	Trackpad and key row go through gamescope's input; KDE Connect only for accents and emoji The pad reaches whichever panel has focus (Steam's menus too), needs nothing installed, and no longer clamps to 1280x720. Characters that aren't on a US keyboard start KDE Connect the first time they're typed. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>	2026-09-29 20:03:37 +10:00
saphidandClaude Sonnet 5.5	60ade8c2e8	Merge origin/main into live-touch Kept both route tables: main's media, agent, assistant and Mac view routes plus /api/touch. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>	2026-09-29 11:04:47 +10:00
saphidandClaude Opus 5.5	aa1ac7368c	frame_touch: any event that goes through clears the stale flag A trackpad move names no panel, so waiting for an aimed event could leave the page re-reading panels for the rest of the session; a release still aimed at the old panel doesn't count. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-09-29 10:13:09 +10:00
saphidandClaude Opus 5.5	46b6966cf7	frame_touch: build the socket path on the Frame, so Windows can import it for tests Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-09-29 09:41:42 +10:00
saphidandClaude Opus 5.5	be2e770e66	Control: stale clears, pauses reconverge, pastes split per request - The Frame says it has caught up as soon as an aimed event lands after a stale one, so the page stops re-reading the panels. - After a device pause it lets go of everything it holds (releases that arrived while paused were dropped), and waits for the device once per batch, not once per event. - The quick focus check no longer freshens the panel geometry's age. - Each request carries at most about 100 characters of text. - Turning Control off while it connects doesn't report an error. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-09-29 09:40:00 +10:00
saphidandClaude Opus 5.5	597f98af6d	Control: fixes from the SWE-2 Max review - The Frame side tracks keys as well as buttons and lets go of both when the session ends. - A stale tap tells the page, which re-reads the panels at once. - A paused input device waits instead of ending the session; only a disconnect does. An OS error on one event skips it. - Presses check focus with two property reads and do the full lookup only when it changed. - Writes to an agent's stdin are serialized, so two devices sending at once can't tear a line (the keyboard agent too). - Connecting gives up with a message after 15 s instead of hanging on "Connecting…"; text goes in 100-character pieces so releases don't wait behind a long paste; a cancelled mouse gesture releases what's held. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-09-29 09:28:28 +10:00
saphidandClaude Opus 5.5	ac07efa8f1	Control: close the targeting gaps from the second review - The focused panel's display comes from GAMESCOPE_FOCUS_DISPLAY (gamescope packs ":1" into the first value), so a window id repeated across :0 and :1 can't be mistaken; the pid is only the fallback. - Presses, keys, text and scrolls read focus afresh on the Frame; only moves use a reading up to a second old. - A gesture remembers the panel it started on and does nothing more if that stops being the one in use; a press with no panel to aim at isn't sent. - Opening a screenshot clears the panel Control would act on; switching to another app releases held keys and buttons. - Trimming keeps a click with its position; the error backoff holds for new input too. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-09-29 08:52:00 +10:00
saphidandClaude Opus 5.5	0f4f0b863f	Control: fixes from review - Keys held on the Frame are released with buttons when Control stops or the view loses focus; keys for the Frame no longer trigger Frame Control's own shortcuts. - Taps only act when the picture on screen is the panel in use; positions, presses, keys, text and scrolls name their panel (display and window: ids repeat across :0 and :1, told apart by pid), and the Frame drops them if focus has moved on. Releases always go. - While connecting, a tap keeps its position; on an error only releases wait and retries back off; trimming a long queue never drops a release. - Lifting one of two scrolling fingers ends the scroll; a cancelled touch isn't a tap; clicks and holds on the bars around the picture do nothing. - A capture loop from before a Live restart can't stop the new video. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-09-29 08:40:46 +10:00
saphidandClaude Opus 5.5	e7c81733b1	Live view: a Desktop view that stays still, and Control to tap on the Frame The live view gets a second source and a way to use the Frame from it: - Desktop: the app panel in use in the headset, streamed from its own window (x11grab of gamescope's redirected window), so it doesn't move as the wearer looks around. A picker shows any other panel, view only. - Control: on the Desktop view a tap or click lands exactly where you put it; drag is a mouse drag, press and hold right-clicks, two fingers scroll, and on a computer the mouse, wheel and keyboard work directly. On the headset view the view is a trackpad. A text field and key row type from a phone. Input goes through gamescope's own EIS socket (the way Steam feeds Remote Play input) with the libei already on the image: ui/frame_touch.py, over the same long-lived ssh machinery as the keyboard agent, nothing to install. It reaches the panel that has focus on either X display, which the KDE Connect route can't. Verified on the Frame and from the iPhone app in the Simulator. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-09-29 08:23:55 +10:00