Record v0.4.48 candidate Frame smoke

Merge remote-tracking branch 'origin/main' into release/v0.4.48
Merge pull request #335 from saphid/feat/framey-mpris-compat
2026-10-26 21:03:09 +01:00 · 2026-10-26 15:46:53 +00:00 · 2026-10-26 15:45:09 +00:00 · 2026-10-26 15:44:46 +00:00 · 2026-10-26 15:42:38 +00:00 · 2026-10-26 15:31:25 +00:00
48 changed files with 1923 additions and 128 deletions
@@ -1,12 +1,12 @@
 {
  "name": "frame-control",
-  "version": "0.4.44",
+  "version": "0.4.48",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "frame-control",
-      "version": "0.4.44",
+      "version": "0.4.48",
      "license": "MIT",
      "devDependencies": {
        "electron": "^44.4.5",
@@ -1,7 +1,7 @@
 {
  "name": "frame-control",
  "productName": "Frame Control",
-  "version": "0.4.44",
+  "version": "0.4.48",
  "description": "Desktop app for managing a Valve Steam Frame over SSH",
  "private": true,
  "main": "main.js",
@@ -0,0 +1,32 @@
+# Chunked Framey frontend audit route, 26 October 2026
+
+The local 116-plugin Chromium audit served chunked modules at a route that
+omitted the store receipt, while the production panel requested
+`/framey/module/<id>/<receipt>/<file>`. The audit parsed that receipt as part
+of the file path and returned 404. This made its result for chunked frontends
+weaker than the separate targeted panel checks.
+
+The audit now accepts the production URL shape only when the plugin ID,
+receipt and JavaScript path are valid, the receipt equals the catalog SHA-256,
+and the cached archive bytes match that SHA-256. Invalid IDs, receipts, paths
+and changed archive bytes fail before the module is served. The production
+Framey panel and installer are unchanged.
+
+## Exact archived browser check
+
+Pinned official Deck Shelves 2.0.0 (store ID 135, SHA-256
+`b566280ad38fd3ecd584b5b46a855f301539eb9a86063834c64b7045f7063f91`)
+ran through the repaired audit in an opaque Chromium iframe. Its entry module
+and all eight JavaScript chunks returned HTTP 200 at receipt-bound URLs. The
+frontend reported ready and called `get_settings`; the audit denied that
+backend call and a Steam library read. Plugin network access remained blocked
+by the audit policy. The previous
+catalog browser observation had failed to resolve `./chunks/...` from a blob
+URL. This check verifies the current audit route and frontend initializer,
+not the official backend or a live shelf.
+
+The focused route regression covers entry and chunk reads plus wrong receipt,
+path traversal, malformed ID and changed archive bytes. The catalog's
+**4 works / 50 partial / 51 broken / 11 N/A** statuses are unchanged. Deck
+Shelves remains partial; installed settings, home-shelf behavior, worn VR and
+physical controller input remain unverified.
@@ -4,7 +4,17 @@ The exact official Deck Shelves 2.0.0 archive (store ID 135, SHA-256 `b566280ad3

 Framey now serves JavaScript files from the managed plugin's `dist` directory using hierarchical module URLs. Its opaque `allow-scripts` iframe still has no Frame UI key. Local Chromium received HTTP 200 for the entry and eight chunks, reported the initializer ready, and rendered the settings panel with “Enable shelves on Home,” “Create default shelves,” “Behavior,” and “Shelves.” The browser audit denied the attempted `get_settings` backend call, Steam library read and plugin network access. No backend method executed.

-The catalog moves this exact version from broken to **partial** for visible local settings only. The plugin's main feature injects shelves into Steam Home; Framey has no verified Steam Home patch target. Settings writes, official backend behavior, real Frame module serving, wearer-visible VR, and physical controller input remain unverified. The [compatibility table](../framey-compatibility.md) and store views retain these limits.
+The catalog moves this exact version from broken to **partial** for visible local settings. The plugin's main feature injects shelves into Steam Home; Framey has no verified Steam Home patch target. Actual Decky RPC, real Frame settings, wearer-visible VR, and physical controller input remain unverified. The [compatibility table](../framey-compatibility.md) and store views retain these limits.
+
+## Isolated official backend settings check
+
+I verified the same archive digest before loading its unchanged `Deck-Shelves/main.py` in local Python. A stub `decky` module supplied only a logger; `DECKY_PLUGIN_SETTINGS_DIR` and `DECKY_HOME` pointed inside a temporary directory. No Decky service, headset, Steam API, or network call was involved. Calling `_main`, `get_settings`, and `set_settings` returned the default disabled state, saved one shelf named `Local Test`, and returned that shelf from a fresh `Plugin` instance. The temporary directory was removed after the check.
+
+```json
+{"archiveSha256":"b566280ad38fd3ecd584b5b46a855f301539eb9a86063834c64b7045f7063f91","defaultEnabled":false,"defaultShelves":0,"saveResult":true,"reopenedEnabled":true,"reopenedShelfTitle":"Local Test","settingsFileExists":true}
+```
+
+This proves only the archive's Python settings logic under those local conditions. It does not prove that Decky 3.3.0 can dispatch these methods on the ARM64 Frame, that the opaque panel can save settings through the production bridge, or that a shelf appears on Steam Home or in VR.

 ## Exact source real Frame gates

@@ -0,0 +1,311 @@
+{
+  "checkedAtUtc": "2026-10-26T09:28:48.295443+00:00",
+  "plugin": {
+    "id": 124,
+    "name": "AlarMe",
+    "version": "1.6.3",
+    "sha256": "17d4166a9e98979df5fdb07c7eae42317acd54a453d3b82757508f971193c0fe"
+  },
+  "status": "partial",
+  "sharedControls": {
+    "ConfirmModalOfficialImporters": 43,
+    "FocusableOfficialImporters": 65,
+    "claim": "Import counts show shared surface, not successful behavior in every plugin. Only AlarMe received a real-backend follow-up."
+  },
+  "realFrame": {
+    "os": "Frame OS 0.5.6",
+    "arch": "aarch64",
+    "decky": {
+      "version": "v3.3.0",
+      "sha256": "8ef5dcf36cbbbb6e97201a6baed5d79c4cc44ec27789fc9af1c5b6ae8f0b25b6"
+    },
+    "transport": "trusted SSH through coordinator host; receipt-bound real CEF Decky RPC/events",
+    "isolation": "Exact official archive installed by production APPLY into a random private path. Removable unprivileged user service, not enabled, RuntimeMaxSec=900 and TimeoutStopSec=5.",
+    "settings": {
+      "timer_subtle_mode": true,
+      "timer_volume": 0,
+      "timer_auto_suspend": false,
+      "timer_prevent_sleep": false,
+      "pomodoro_subtle_mode": true,
+      "pomodoro_volume": 0,
+      "pomodoro_prevent_sleep": false,
+      "overlay_enabled": false
+    },
+    "safeRpcResults": [
+      {
+        "method": "create_timer",
+        "args": [
+          300,
+          "Framey silent private timer",
+          true,
+          false,
+          false
+        ],
+        "result": "91c1f87d"
+      },
+      {
+        "method": "pause_timer",
+        "args": [
+          "91c1f87d"
+        ],
+        "result": true
+      },
+      {
+        "method": "save_preset_from_timer",
+        "args": [
+          "91c1f87d"
+        ],
+        "result": {
+          "id": "47c046cd",
+          "seconds": 300,
+          "label": "Framey silent private timer",
+          "subtle_mode": true,
+          "auto_suspend": false,
+          "prevent_sleep": false
+        }
+      },
+      {
+        "method": "remove_preset",
+        "args": [
+          "47c046cd"
+        ],
+        "result": true
+      },
+      {
+        "method": "cancel_timer",
+        "args": [
+          "91c1f87d"
+        ],
+        "result": true
+      },
+      {
+        "method": "stopwatch_start",
+        "args": [],
+        "result": {
+          "status": "running",
+          "start_time": 1793006404.791917,
+          "elapsed_ms": 0,
+          "laps": [],
+          "prevent_sleep": false,
+          "current_elapsed_ms": 1.0344982147216797
+        }
+      },
+      {
+        "method": "stopwatch_lap",
+        "args": [],
+        "result": {
+          "status": "running",
+          "start_time": 1793006404.791917,
+          "elapsed_ms": 0,
+          "laps": [
+            {
+              "label": "Lap 1",
+              "absolute_ms": 31747.3783493042,
+              "split_ms": 31747.3783493042
+            }
+          ],
+          "prevent_sleep": false,
+          "current_elapsed_ms": 31750.77533721924,
+          "total_lap_count": 1,
+          "lap_limit_reached": false
+        }
+      },
+      {
+        "method": "stopwatch_pause",
+        "args": [],
+        "result": {
+          "status": "paused",
+          "start_time": null,
+          "elapsed_ms": 34339.426040649414,
+          "laps": [
+            {
+              "label": "Lap 1",
+              "absolute_ms": 31747.3783493042,
+              "split_ms": 31747.3783493042
+            }
+          ],
+          "prevent_sleep": false,
+          "current_elapsed_ms": 34339.426040649414,
+          "total_lap_count": 1,
+          "lap_limit_reached": false
+        }
+      },
+      {
+        "method": "stopwatch_reset",
+        "args": [],
+        "result": {
+          "status": "idle",
+          "start_time": null,
+          "elapsed_ms": 0,
+          "laps": [],
+          "current_elapsed_ms": 0
+        }
+      }
+    ],
+    "eventCounts": {
+      "alarme_timers_updated": 3,
+      "alarme_sleep_inhibitor_updated": 6,
+      "alarme_timer_tick": 124,
+      "alarme_presets_updated": 2,
+      "alarme_stopwatch_updated": 3
+    },
+    "finalReadback": {
+      "timers": [],
+      "stopwatch": {
+        "status": "idle",
+        "start_time": null,
+        "elapsed_ms": 0,
+        "laps": [],
+        "current_elapsed_ms": 0
+      },
+      "sleep": {
+        "active": false,
+        "items": []
+      },
+      "presets": [
+        {
+          "id": "preset-5",
+          "seconds": 300,
+          "label": "5 minutes",
+          "subtle_mode": false,
+          "auto_suspend": false
+        },
+        {
+          "id": "preset-10",
+          "seconds": 600,
+          "label": "10 minutes",
+          "subtle_mode": false,
+          "auto_suspend": false
+        },
+        {
+          "id": "preset-15",
+          "seconds": 900,
+          "label": "15 minutes",
+          "subtle_mode": false,
+          "auto_suspend": false
+        },
+        {
+          "id": "preset-30",
+          "seconds": 1800,
+          "label": "30 minutes",
+          "subtle_mode": false,
+          "auto_suspend": false
+        }
+      ]
+    },
+    "before": {
+      "decky": "failed",
+      "panel": "inactive",
+      "battery": [
+        97
+      ]
+    },
+    "after": {
+      "decky": "failed",
+      "panel": "inactive",
+      "battery": [
+        96
+      ]
+    },
+    "cleanup": {
+      "baseAbsent": true,
+      "unitAbsent": true
+    },
+    "lockReleased": true
+  },
+  "browser": {
+    "host": "Repository headset.html and opaque allow-scripts iframe with bundled React 18.3.1; loopback RPC/event relay to the real ARM64 backend",
+    "verified": [
+      "labeled silent timer creation and live tick display",
+      "timer pause through onActivate and backend readback",
+      "save paused timer as preset through onActivate",
+      "delete confirmation shows preset name and description",
+      "Cancel closes dialog without dispatching remove_preset; backend readback retains preset",
+      "Delete invokes remove_preset once and readback removes the private preset",
+      "timer cancellation",
+      "Watch tab activation; stopwatch start/lap/pause",
+      "fresh panel reopen retains paused 34.339-second stopwatch and one lap",
+      "stopwatch reset; no active timers or sleep inhibitors in final backend readback"
+    ],
+    "domFixture": {
+      "type": "fixture:result",
+      "checks": [
+        "description visible",
+        "underlying panel inert",
+        "dialog fixed",
+        "Tab wraps in top dialog",
+        "Cancel callback once",
+        "parent draft preserved",
+        "disabled actions",
+        "old Close retains child",
+        "programmatic Close skips callback",
+        "OK does not close newly opened dialog",
+        "Update changes body",
+        "Escape cancels top dialog",
+        "panel reactivated",
+        "pointer Enter Space activate once each"
+      ]
+    },
+    "limits": "Local Chromium with real backend, not the deployed headset HTTP host or worn VR. Synthetic DOM checks use programmatic DOM events, not physical controllers."
+  },
+  "fixtureCorrection": {
+    "issue": "Initial seed used settings/<display-name>; actual Decky uses settings/<folder>. Safety assertion failed on readback before any timer action.",
+    "resolution": "First private service/data removed and lock released. Correct folder seed read back before second run exposed actions."
+  },
+  "cleanupAudit": {
+    "servicesAudited": 2,
+    "allBaseUnitArchiveAbsent": true,
+    "allLoadStateNotFound": true,
+    "allActiveStateInactive": true,
+    "allMainPidZero": true,
+    "sharedLock": "Fresh atomic lock acquired and released for cleanup audit"
+  },
+  "unverified": [
+    "audio playback and sound imports",
+    "alarms and reminders",
+    "auto-suspend and /dev/uinput sleep inhibition",
+    "in-game/global Steam overlay: no injection target in isolated panel",
+    "background notifications after panel closes",
+    "worn VR and physical controller/keyboard input"
+  ],
+  "validation": {
+    "fullPython": {
+      "ran": 1628,
+      "skipped": 16,
+      "result": "pass"
+    },
+    "nodeContracts": [
+      "tests/page/framey_actions.mjs",
+      "tests/page/framey_running.mjs"
+    ],
+    "siteTestFiles": 2,
+    "currentStoreRefresh": {
+      "plugins": 116,
+      "exactIdsVersionsAndDigestsUnchanged": true
+    },
+    "fakeFrame": {
+      "blocked": 56,
+      "installed-removed": 60
+    },
+    "noContextBrowser": {
+      "plugins": 116,
+      "ready": 101,
+      "failed": 15,
+      "noRegressionsAgainstCatalogBaseline": true,
+      "scope": "Initialization only, all backend/network denied; library-dependent plugins lack Steam context"
+    },
+    "contextReplayBrowser": {
+      "plugins": 116,
+      "ready": 104,
+      "failed": 12,
+      "initializationRegressionsAgainstPriorContextReplay": [],
+      "scope": "Synthetic library/running replay; backend and network denied, initialization only"
+    }
+  },
+  "reviewFollowUp": {
+    "checkedAtUtc": "2026-10-26T10:10:05.650676+00:00",
+    "change": "Update reinjects the scoped close callback into replacement React dialogs and uses the replacement close callback.",
+    "verification": "Node regression: updated ConfirmModal OK and Cancel, with and without custom close callbacks; ClosedPromise resolves; original callback not retained; repeated Close/Update inert. Regression reproduced before the fix.",
+    "limits": "No additional local Chromium or real Frame check for this small follow-up; prior runtime evidence applies to initial dialog and workflow paths."
+  }
+}
@@ -0,0 +1,107 @@
+# Framey activation and dialog follow-up — 2026-10-26
+
+AlarMe 1.6.3 now has usable timer, preset and stopwatch controls in the local
+Framey host with its official backend running on the ARM64 Frame. It remains
+**partial**. This check does not establish audio, alarm/reminder, sleep-control,
+background-notification or worn-VR compatibility.
+
+The exact archive is store ID 124, SHA-256
+`17d4166a9e98979df5fdb07c7eae42317acd54a453d3b82757508f971193c0fe`.
+See the [structured results](framey-dialog-controls-2026-10-26.json).
+
+## Reproduced blockers and repairs
+
+AlarMe uses DFL `Focusable.onActivate` for timer pause, save-as-preset, cancel,
+preset deletion, tabs and stopwatch controls. Framey's previous `div`
+passthrough ignored that callback: clicks on the save/pause controls did not
+dispatch backend calls. Focusable now maps pointer activation and Enter/Space
+to plugin callbacks, exposes a keyboard focus target and respects disabled
+controls. A click does not invoke both `onClick` and `onActivate` when a plugin
+supplies both; nested activation stops bubbling to the parent action.
+
+The previous ConfirmModal omitted `strDescription`, Cancel, middle actions and
+disabled flags. showModal did not inject a `closeModal` callback into custom
+dialog components, and every Close handle cleared the same root. A confirmation
+opened by another dialog could therefore disappear when the earlier action
+closed. Dialogs also appeared below the panel's long page content.
+
+Dialogs now occupy a scrollable overlay inside the opaque iframe. They preserve
+the underlying dialog's mounted state, receive scoped close callbacks, support
+Close/ClosedPromise/Update, show confirmation descriptions and cancel/middle
+actions, and respect disabled flags. The underlying plugin surface becomes
+inert while a dialog is open; Tab stays in the top dialog, Escape cancels it and
+closing restores focus. Steam popouts and controller navigation are not emulated.
+
+43 official archives import ConfirmModal and 65 import Focusable in this
+snapshot. These are shared API surfaces, **not** verification or status
+promotions for every importing plugin.
+
+## Real backend and local browser verification
+
+Held the normal atomic shared headset lock. Installed the exact official archive
+through the production archive validation/extraction path into a random private
+directory. Used published Decky 3.3.0 ARM64, an unprivileged user service that was
+never enabled, with a 900-second runtime bound and five-second stop timeout.
+RPCs and events used Framey's production receipt-bound bridge through real Steam
+CEF. The Chromium host served repository headset.html, React and framey-host.js;
+its status endpoints were fixture-shaped, while AlarMe RPCs/events were live.
+
+The initial private settings seed used the plugin display name instead of the
+archive folder. A safety assertion failed on readback of the defaults before any
+timer action. That service/data was removed and the lock released. The corrected
+run read back subtle mode, zero volume, no auto-suspend, no sleep inhibition and
+no overlay before exposing actions. Its relay allowed only the documented safe
+methods; sound, suspend, sleep-inhibitor and arbitrary plugin actions were denied.
+
+Verified with actual browser clicks and real backend readback:
+
+1. Add Label opened a custom timer dialog. Created a silent five-minute timer
+   named `Framey silent private timer`; live backend ticks changed its display.
+2. Pause and save-as-preset activated after the Focusable repair. Backend
+   readback reported a paused timer and its saved preset.
+3. Delete Preset showed the preset's name in its confirmation description.
+   Cancel closed the dialog without dispatching `remove_preset`; readback kept
+   the preset. Reopening and choosing Delete dispatched it once and removed it.
+4. Cancel removed the private timer. Watch opened the stopwatch; Start, Lap and
+   Pause produced real backend state and events.
+5. Closing and reopening the panel retained the paused stopwatch at 34.339
+   seconds and one lap. Reset cleared it. Final readback showed no active timers,
+   no laps and no active sleep inhibitor.
+
+A separate local Chromium DOM fixture passed 14 checks for nested-dialog state,
+scoped handles, descriptions, disabled buttons, Cancel, Escape, Tab wrapping,
+Close/ClosedPromise/Update and pointer/Enter/Space activation. These programmatic
+DOM checks do not verify physical input devices.
+
+Review follow-up: Update also injects the scoped close callback into replacement
+dialogs. Node regression contracts update to ConfirmModal and exercise both OK
+and Cancel, with and without a plugin close callback, then await ClosedPromise.
+They verify that the replacement's callback runs once and the original callback
+is not retained. This extends the local host's Update behavior so replacements
+remain dismissible; this follow-up was not rerun in Chromium or on the headset.
+
+## Cleanup and remaining limits
+
+Removed both private service units, bases and uploaded archives; reloaded the
+user service manager and released the matching shared lock. A fresh locked audit
+confirmed both units were not found, inactive and PID zero, with all test paths
+absent. Managed Decky remained failed and the headset panel inactive, matching
+the initial state. Battery was 97% before and 96% after. No power settings changed.
+
+AlarMe stays partial. Audio, sound imports, alarms/reminders, auto-suspend and
+`/dev/uinput` sleep inhibition were not exercised. Steam's global/in-game overlay
+has no injection target inside Framey's isolated panel. Notifications require
+the plugin panel to remain open. The deployed headset HTTP host, worn VR and
+physical controller/keyboard input were not tested in this pass.
+
+The store and documentation use the same exact-digest catalog reason. Aggregate
+counts remain **4 works / 49 partial / 52 broken / 11 N/A**.
+
+Validation: all 116 official IDs/versions/digests unchanged on store refresh;
+fake-Frame 60 installed/removed and 56 blocked; full Python suite 1,628 tests,
+16 skipped; Framey action/running Node contracts and both site test files pass.
+The no-Steam-context Chromium pass attempted all 116 frontends (101 initialized,
+15 failed); backend and network access were denied throughout that pass.
+The repeat with synthetic library/running context initialized 104 of 116, with no
+initialization regressions against the prior context-replay pass. Neither
+initialization pass is a useful-functionality check.
@@ -0,0 +1,40 @@
+# Emuchievements ARM64 hash helper feasibility, 26 October 2026
+
+The exact official Emuchievements 2.0.5 archive (store ID 28, SHA-256
+`98dcb443e81b9f9011cfe77c69eb659869c8e2df2df8b0a443df66cbfc2f5a89`)
+contains an x86_64 `Emuchievements/bin/hash`. Frame Control still blocks
+that archive on ARM64; this experiment did not install the plugin.
+
+The upstream source commit
+[`8567e94befffc943434b2adb842487274815f8bb`](https://github.com/EmuDeck/Emuchievements/commit/8567e94befffc943434b2adb842487274815f8bb)
+declares version 2.0.5. Its `src/py/main.py` matches the published ZIP's
+`Emuchievements/main.py` byte for byte (SHA-256
+`d4e72f136c94e48919575937ec4190f28864cc259eb111ef47f0df99f5912645`).
+The pinned build dependencies at that commit are libarchive
+`b3be94ba4f36943745e64a6a0a3c21c2d1281d3c`, libchdr
+`a20e04c12c0c20048bf771da6df7aa2e51f5e0cb`, and rcheevos
+`85a3209398e576d79170f569fcddf277640f3f06`.
+
+On a separate Linux host, the version-matched source and submodules built an
+x86_64 `hash` with CMake. It and the official x86_64 binary both returned
+`ff78ca6c21ac11504dbddbd5d4e7524a` for one synthetic `.rom` file. An
+isolated Debian cross-build using `gcc-aarch64-linux-gnu` and
+`g++-aarch64-linux-gnu` produced an AArch64 binary with SHA-256
+`9c7aedb80bdd64941aa5dd9b41f9bb8471411c812e04c7ee7d60486779d99997`.
+It links to `liblzma.so.5`, `libstdc++.so.6`, `libgcc_s.so.1`, and `libc.so.6`.
+
+A real Frame test acquired `/tmp/frame-test.lock` atomically with a unique
+owner before reading the device. SteamVR activity was **3** (standby),
+proximity raw **3.0625**, and battery **100%**. The ARM64 helper ran against
+the same synthetic ROM in a private `/tmp` directory, exited 0, and returned
+the same hash. The owned directory and lock were removed. No normal service,
+power setting, Steam library, real ROM, or installed plugin was changed.
+The separate host's source/build directory was also removed after the test.
+
+This proves only a single-file helper path. The official ZIP remains blocked
+because it still bundles x86_64 bytes. A release-ready port needs a packaged
+ARM64 helper with GPL-3.0 source and license compliance, format-specific hash
+coverage (including archives and CHD), a managed plugin transaction, actual
+Decky backend and frontend checks, and cleanup. RetroAchievements login,
+real ROM scanning, wearer-visible VR, and physical controller use remain
+unverified.
@@ -0,0 +1,49 @@
+# Free Loader duplicate archive entries, 26 October 2026
+
+The exact official Free Loader 1.6.0 archive is store ID 63, SHA-256
+`05208aee6f6ba824391d8ddc81b1168b2599a9711e7528cdaa789f6cc710b42a`.
+It has 23 ZIP entries. Seven names under `free-loader/py_modules/` occur
+twice. Each duplicate pair has identical uncompressed bytes and file type;
+five Python files and `.keep` differ only between mode `0644` and `0755`.
+The directory entry is identical. No path escape, symlink or alternate content
+was accepted.
+
+The installer now accepts an exact duplicate name only when its bytes match
+and its mode differs at most in execute bits. Both desktop validation and the
+headset transaction enforce that rule before extraction. The existing member
+count, unpacked-size, per-member-size, root, path and ARM64 checks still run.
+Synthetic tests reject changed duplicate payloads and non-execute mode changes.
+
+## Scoped verification
+
+- The exact archive passed the revised validator. A private local transaction
+  installed and removed its `free-loader` folder and receipt; cleanup left no
+  plugin folder. The focused store suite passed 21/21 tests, including a
+  duplicate-member install/remove and permission readback.
+- After merging current main, the full local Python suite passed **1,637
+  tests, 16 skipped**. The generated compatibility document check and
+  whitespace check passed.
+- The pinned official fake-Frame HTTP/SSH install/remove test passed with this
+  archive alongside the other pinned fixtures. It ran in a uniquely named
+  disposable Compose project; its containers, network and volumes were removed.
+  The fake does not execute the plugin's Python backend.
+- The current Framey opaque Chromium host on main `d963305` initialized the
+  exact frontend. Its **Free Games** view rendered, then displayed “Failed to
+  load games!” because the audit intentionally denied all backend/network
+  calls. It attempted `settings_read`, `read_deals` and logger methods.
+  The browser audit's former `local_bundle` stub had returned HTTP 404 after
+  receipt-bound panel lookup was introduced; the audit now supplies the
+  digest-checked bundle and receipt to the shipped panel renderer.
+- Exact official Python backend code ran in a disposable Python 3.12 container
+  with network disabled, read-only root, no capabilities, a private data mount
+  and a minimal `decky` API stub. `_main`, `settings_read` and `read_deals`
+  succeeded: 14 default settings, a 12-hour update frequency, an empty deals
+  map, and only private `settings.json`/`deal_db.json` files. The container
+  and its private files were removed. No feed refresh or notification ran.
+
+This makes **partial** the accurate digest-scoped status. The earlier full
+116-plugin fake-Frame catalog audit blocked this archive before the validator
+change; the focused pinned flow now passes. Actual Decky 3.3.0 backend load,
+live giveaway feeds, notification delivery, headset install, worn UI and
+physical controller input remain unverified. No real Frame session or service
+was touched for this change.
@@ -0,0 +1,7 @@
+# Game Theme Music local panel check, 26 October 2026
+
+The exact official Game Theme Music 1.7.1-1 archive (store ID 52, SHA-256 `9ce293ab4db212c03c6b96dfbc5e4d92e874d33387463f53223773921f75a80e`) passed the existing fake Frame install/remove audit. Its prior local Chromium run stopped before initialization with `Cannot read properties of null (reading 'type')`: the frontend dereferenced the result of `DFL.fakeRenderComponent` while looking for Steam's Library Context Menu.
+
+Framey's isolated host now returns an inert local component type from that lookup. The patch API remains a no-op and does not expose or modify a Steam React tree. In the repository's opaque Chromium audit, the unchanged archive reported initializer ready and rendered a Settings view containing Music Volume, Default Muted, Use yt-dlp, Invidious Instance, Download Music, Overrides and Extras. The audit observed a `get_setting` request, but denied the backend call. It also denied plugin network requests; a YouTube/Invidious fetch failed as expected. The bounded root-text observation came from the test iframe and contained only these public UI labels.
+
+The catalog therefore moves this digest from **broken** to **partial** for the visible local settings panel. No theme was played or injected into a Steam game page. Music search, playback, downloads, settings persistence, live ARM64 backend behavior, wearer-visible VR and physical controller input remain unverified. The earlier failed browser observation remains in the canonical JSON alongside this follow-up so the change in evidence is explicit.
@@ -0,0 +1,34 @@
+# Music Control 1.1.7 bound-method compatibility, 26 October 2026
+
+The official Decky store archive for ID 111, version 1.1.7, is
+`3f56a3f56034b277ea74a2c37cc84133b69e382aa6bcb0b43876776aac737ed9`
+(SHA-256). The pinned `tests/fixtures/framey-official/111.zip` matches that
+digest and includes the upstream license.
+
+The unchanged backend fails before it reaches D-Bus: `sp_list_media_players`
+raises `TypeError: Plugin._get_dbus_env() takes 1 positional argument but 2
+were given`, and `sp_play` raises the corresponding `_sp_player_dbus` argument
+error. The source passes `self` explicitly to methods already bound by Python.
+
+For this exact store ID, archive digest and folder, a managed install removes
+the redundant argument at the five affected call sites. It checks the number
+of occurrences before writing `main.py` and records
+`music-control-bound-methods` in the managed receipt. The original ZIP remains
+the verified download; the older ID 12 archive is installed without this
+change.
+
+`test_exact_music_control_backend_calls_work_after_managed_install` installs
+the official ZIP through the production transaction script into a disposable
+home. It imports the patched backend and exercises player enumeration,
+selection, play/pause, next/previous, volume and playback-status calls against
+a private fake `dbus-send` executable that records the actual command
+arguments. It then removes the plugin through the receipt-bound transaction.
+The same test confirms ID 12 retains its original backend source. The focused
+store suite passed **23/23** tests locally. The pinned frontend/fake-Frame
+install/remove tests are part of the hosted gate.
+
+This proves that the Python argument mismatch no longer prevents backend
+command dispatch in the isolated fixture. The fixture is not an MPRIS player.
+Actual Decky 3.3.0 ARM64 execution, live player discovery, media transport,
+volume effects, album-art routing, and wearer-visible VR controls have not
+been verified. Music Control remains **partial**.
@@ -0,0 +1,9 @@
+# Shotty Python compatibility, 26 October 2026
+
+The exact official Shotty 0.1.0 archive (store ID 53, SHA-256 `ab7f6618b264a0cb766525e788cef6c3e1478c0fef98a701225e5e8af441e2fe`) imports `click.get_app_dir` at startup but never calls it. The archive includes an empty `py_modules` directory and no `click` package. A prior actual Decky 3.3.0 amd64 backend check stopped at `ModuleNotFoundError: click`; its local frontend separately starts with Framey's read-only Steam library snapshot.
+
+Frame Control now writes a small Linux `click.get_app_dir` compatibility module into **only this exact digest's** managed `Shotty/py_modules` folder during staging. Decky Loader adds each plugin's `py_modules` folder to that plugin's Python search path. The staging transaction records `shotty-click-app-dir` in the receipt and removes the whole staged folder on failure. A different Shotty digest receives no module. The official ZIP bytes and their verified hash remain unchanged.
+
+An isolated transaction test installed the pinned archive, imported its unchanged `main.py` using the staged module, and called its `aggregate_all` method with a synthetic Steam screenshot under a temporary `HOME`. It copied one fixture image into that temporary home's `Pictures/Screenshots/Local Test Game` folder; reopening the copied bytes matched the source. Removal deleted the managed folder. A second synthetic Shotty archive with another digest installed without the module. The test neither started the plugin's continuous screenshot rescuer nor touched a person's Steam library or screenshots.
+
+This supports **partial** compatibility for the local frontend and a narrow backend copy path. Actual Decky 3.3.0 ARM64 plugin startup, gamescope screenshot rescue, real screenshot aggregation, VR panel visibility, and physical controller use remain unverified. No headset lock was acquired or headset state changed for this check.
@@ -0,0 +1,33 @@
+# Tailscale Control read-only backend and Decky PATH, 26 October 2026
+
+The audited archive was official Tailscale Control 0.1.3, store ID 43,
+SHA-256 `06411711b27101d438339000da3d91202d682862710b02ef3ddf2462e642448a`.
+Earlier local Chromium evidence showed its settings panel. This check focused
+on the Frame's CLI lookup; it did not run a live Framey panel RPC.
+
+Each real Frame check acquired `/tmp/frame-test.lock` atomically with its own
+random owner, read SteamVR activity and proximity, and released only that
+owner's lock. The headset was in standby. The installed Tailscale CLI wrapper
+resides in `~/.local/bin`, which the systemd user manager did not put in the
+Decky service's inherited `PATH`.
+
+| Check | Result |
+| --- | --- |
+| Exact official backend with the current service PATH | Three read-only status methods returned `None`; `tailscale` was not found. |
+| Same backend in a disposable process with `~/.local/bin` prepended | The read-only methods returned active state, two exit-node entries and 16 device entries. |
+| Bounded transient systemd user unit with the proposed service PATH | Found `tailscale` and completed `tailscale status`. The unit ended inactive, PID 0, `LoadState=not-found`. |
+
+The Frame Control managed Decky unit now sets `PATH` to `~/.local/bin` plus
+standard system directories when installed or updated. The install transaction
+rolls its prior unit back on failure. No Tailscale `up`, `down`, routing or
+exit-node change was run. No persistent test service, headset wake, controller
+input or settings write was used.
+
+This supports CLI discovery and read-only backend data on the real Frame. It
+does not prove the production Framey-to-Decky RPC, connection controls, QR
+asset, worn panel visibility or physical controller usability. Tailscale
+Control remains **partial** in the digest-scoped catalog.
+
+A later independent hourly read-only check found SteamVR activity 3
+(standby), proximity raw 3.0625 and battery 93%. It released its owned lock;
+no worn test was possible and the hourly schedule remains enabled.
@@ -0,0 +1,28 @@
+# Read-only Framey activity gate, 26 October 2026
+
+At 11:12 UTC, a read-only probe acquired `/tmp/frame-test.lock` by atomic
+`mkdir` with a random owner token before reading the Frame. SteamVR
+returned two `vrcmd --stats` rows: performance metrics first and the status
+row second. The status row reported activity level **1**. The original
+`framey-worn-check.py` looked only at row zero and reported unknown activity;
+`framey-vr-check.py` used the same row-zero assumption for its wake gate. The
+fixed gates select the unique status row and fail closed if it is missing,
+duplicated or malformed.
+
+The first locked read found 90% battery, proximity raw 222.25, no active
+managed headset panel service and no managed Decky plugin. A subsequent locked
+read found activity 1 and proximity raw 223.625. No reliable wearer
+confirmation was available. No wake, service install, settings write or input
+was attempted.
+
+While activity was 1, a separate owned-lock read captured four seconds from
+`/dev/video99` into a private 640×360 H.264 MP4. It decoded successfully and
+contained active video imagery. The inspected sample did **not** establish
+room passthrough, Frame Control panel visibility, ProtonDB Badges UI or
+controller interaction. The private recording and decoded frame were removed
+after inspection; no room or media images are committed. Each read released
+only its owner-token lock. The hourly worn-check schedule remains enabled.
+
+The local focused safety suite covers a metrics row before the status row,
+awake activity, ambiguous/missing status and foreign-lock refusal. A genuine
+worn visual and physical-controller check remains outstanding.
@@ -0,0 +1,20 @@
+# Interactive Framey worn-check proximity gate, 26 October 2026
+
+The interactive `scripts/framey-worn-check.py` already required an explicit
+operator wear confirmation and a unique `/tmp/frame-test.lock` owner before
+reading SteamVR activity. It did not read proximity. This change makes its
+locked preflight read the raw proximity sensor and stop before its interaction
+window when the reading is missing or invalid. It checks activity, proximity
+and battery again before input. The same owned-lock cleanup applies on failure.
+
+The focused local gate suite passes 9/9 tests, including missing and nonfinite
+proximity, proximity disappearing between reads, metrics preceding the SteamVR status row,
+standby, low battery, no operator confirmation and a foreign lock. No headset
+input was sent for this change. A separate owner-locked read-only Frame check
+found SteamVR activity 3 (standby), proximity raw 3.0625 and battery 93%; it
+released its lock without a worn test.
+
+The raw proximity value is not calibrated as proof of wear. The operator's
+in-person confirmation remains required; awake activity, proximity and trusted
+synthetic input alone do not prove wearer-visible pixels or physical controller
+usability. The hourly worn-check schedule remains enabled.
@@ -0,0 +1,84 @@
+# v0.4.45 candidate gate, 26 October 2026
+
+The candidate starts from main commit
+`f88e2ed209167a836282a969a71df4c897e658a8`, after PR #316 bound
+Framey chunk URLs to installed store receipts and PR #317 fixed shared Decky
+activation and confirmation controls. PR #319 also added a bounded retry to
+the fake Frame test image after Valve's ARM64 package server repeatedly
+truncated downloads. The app and lockfile are bumped to 0.4.45. The official
+116-plugin catalog remains **4 works / 49 partial / 52 broken / 11 N/A**.
+AlarMe remains partial: its silent timer, preset and stopwatch paths were
+exercised with the official ARM64 backend, while sound, reminders, sleep
+controls, closed-panel notifications and worn VR were not verified.
+
+## Locked real Frame smoke
+
+At 10:26 UTC, `scripts/frame-smoke.sh` ran on that combined main commit after
+atomically acquiring its own `/tmp/frame-test.lock`. Read-only preflight found
+SteamVR activity 3 (standby), proximity 6.3125 and battery 95%. On Frame OS
+0.5.6 build `20261022.6153909`, ARM64 and Proton test titles installed,
+launched and were removed. The optional x86_64 title installed and was
+removed, but its launch was skipped because Steam Linux Runtime 4 is absent.
+The result was **12 passed / 1 skipped / 0 failed**. Owned process and title
+cleanup passed, the command exited 0 and released its lock. The private
+detailed report is
+`tests/smoke/results/2026-10-26T102653Z-20261022.6153909.json` in the
+test checkout.
+
+## Unworn Framey panel exercise
+
+At 10:29 UTC, `scripts/framey-vr-check.py --exercise` ran the same combined
+main commit under a separate random shared-lock owner. It began in standby
+with proximity 6.3125 and battery 95%. The temporary managed panel, Decky
+service and repository sample passed the shipped host's setting save and
+fresh-iframe reopen, quick action, slider and text checks. A trusted
+synthetic OpenVR pointer reached the panel. The scroll buttons moved a
+temporary test region **0 → 120 → 0**; synthetic native wheel input still
+produced no wheel event or movement. The stereo compositor image changed and
+the `/dev/video99` mirror snapshot contained varied, nonblack pixels. This
+single mirror image does not establish moving passthrough content or what a
+wearer sees. The direct overlay image read returned error 24 and zero size,
+so it is not used as texture evidence.
+
+The private report and room-bearing images are in the test host's temporary
+output folder. Reported hashes are stereo before
+`84fe777535870c54cb381bbee3223684d1e0e4f2e6626e6d74ee902a4eec9c1b`,
+stereo after
+`4666d2b0908657489b8cc21520afc3deed4afa26a4c555c782298992b72abdd1`,
+and mirror
+`0769bbc45bd37266cc9ad80154cbd8a44ae3e1577cfa0d419e6af012afbf0fb4`.
+No raw image is committed.
+
+The exercise exited 0 with no cleanup errors, removed its temporary services
+and power recovery timer, restored and read back the original
+`power.pauseCompositorOnStandby=false` and
+`power.turnOffScreensTimeout=5`, found battery 95% and released only its lock.
+Its immediate post-run activity was 0 after the temporary wake. A separate
+locked read-only check at 10:31 UTC found activity **3 standby**, proximity
+6.3125, battery 95%, no cleanup errors, and released its lock.
+
+The sample is not an official plugin. This exercise does not test the new
+receipt-bound chunk path on real hardware or show AlarMe inside VR. Backend
+registration, synthetic pointer delivery and changing compositor pixels do
+not prove physical-controller or wearer-visible usability. No wearer
+confirmation was available, so `scripts/framey-worn-check.py` was not run;
+the hourly worn-headset schedule remains enabled.
+
+## Publication boundary
+
+The version-bumped candidate commit `59ea093` also ran
+`scripts/frame-smoke.sh` under its own shared-lock owner at 10:34 UTC. Its
+locked preflight again found activity 3 standby, proximity 6.3125 and
+battery 95%. The result was **12 passed / 1 optional x86 launch skipped /
+0 failed** on the same Frame OS build. Owned title/process cleanup passed,
+the command exited 0 and released its lock. The private result is
+`tests/smoke/results/2026-10-26T103419Z-20261022.6153909.json` in the test
+checkout. This evidence-only paragraph is the sole change after that smoke.
+
+This is candidate evidence, not a published-release result. Exact-head PR
+and post-merge CI, tagged installers, all ten installer digests with
+`SHA256SUMS`, independent package checks, publisher dry run and public
+`update.json` readback remain required before publication. Physical Mac and
+Windows launch of the eventual tagged bytes, audible alarms, official-plugin
+VR panels, optical readability, physical controllers, haptics and the VR
+keyboard remain unverified.
@@ -0,0 +1,61 @@
+# v0.4.45 tagged release, 26 October 2026
+
+The annotated `v0.4.45` tag dereferences to main merge commit
+`212f0af35c86eb651d5d23bfe0b1e6bf50c528b8` from PR #320. The app and
+lockfile both report 0.4.45. [Post-merge main checks](https://github.com/saphid/frame-control/actions/runs/40309949732)
+passed all seven jobs, including iOS and fake Frame end-to-end tests. The
+[tagged release workflow](https://github.com/saphid/frame-control/actions/runs/40310897979)
+passed its draft, Linux, Windows, Apple Silicon Mac, Intel Mac and checksum
+jobs. The tagged Linux builder launched its AppImage under isolated Xvfb;
+that does not verify a physical display, FUSE mount or headset connection.
+
+## Frame and package gates
+
+The [candidate evidence](v0445-candidate-2026-10-26.md) records two
+shared-lock real Frame smokes: one on the combined main code and one after
+the 0.4.45 version bump. Each finished **12 passed / 1 optional x86 launch
+skipped / 0 failed**, with owned cleanup and lock release. The optional
+x86_64 launch was skipped because Steam Linux Runtime 4 is absent. The
+candidate also records the unworn sample Framey exercise on the combined
+code. Synthetic OpenVR input, setting persistence and scroll-button
+movement passed; native synthetic wheel scrolling did not. The only change
+after the version-bumped smoke was its evidence paragraph.
+
+The draft had ten installers plus `SHA256SUMS`, each with a GitHub SHA-256
+digest. A fresh downloaded checksum list contained exactly those ten names
+and matching digests; its bytes matched GitHub's digest
+`d1d84f03c09881417610337cc48f0025535c8b0d227d55147f1f2b99592625fb`.
+`scripts/publish-release.sh --dry-run v0.4.45` passed the exact remote tag,
+installer and checksum gates after the release notes were attached.
+
+Freshly downloaded packages passed these independent checks:
+
+| Package | Result |
+| --- | --- |
+| Linux x86_64 AppImage | SHA-256 `478ea6535979f049930351d5c0abba14e3bcc4bcb5e695ee7ee945a5fd5bf72f`; launched under isolated Xvfb, bundled server returned HTTP 200 with `FrameControl/1`, and stopped on exit. |
+| Mac arm64 ZIP | SHA-256 `0204b445bc35596170d85f7a1e05e793f1c1b247f3129fadad6f8c92730cf3e2`; ZIP CRC valid, bundle version 0.4.45, main Mach-O CPU arm64. |
+| Mac x64 ZIP | SHA-256 `88ded8bc492501f467a9c51156661f3a25b0dc6347660caf0d2e230bda0f984e`; ZIP CRC valid, bundle version 0.4.45, main Mach-O CPU x86_64. |
+| Windows x64 Setup | SHA-256 `c512d322b2022a233ed26aaa03e038b9a735a2df654ec7a3ebefc1ba86b04334`; PE/Nullsoft installer format. The tagged Windows CI also checked its packaged files and Python libraries. |
+| Linux arm64 DEB | SHA-256 `d08cc96dd18b1a602bd0af33a8e6d1f380d94195aec0f83b2898098956aeedc3`; package version 0.4.45 and architecture arm64. |
+
+Tagged Mac and Windows packages were not launched on physical machines in
+this release gate. Earlier Intel Mac acceptance covers older bytes.
+
+## Publication and limits
+
+`scripts/publish-release.sh v0.4.45` published
+[v0.4.45](https://github.com/saphid/frame-control/releases/tag/v0.4.45) at
+2026-10-26 11:02:08 UTC. GitHub's latest-release API returned
+`draft=false`, `prerelease=false`, the expected tag, ten installers,
+`SHA256SUMS` and `update.json`. A fresh public latest-download of
+`update.json` reported version 0.4.45, the stable release page, ten hashed
+assets and the worn-VR limits in its notes.
+
+The official exact-version Decky catalog remains **4 works / 49 partial /
+52 broken / 11 N/A** out of 116. AlarMe's tested silent timer, preset and
+stopwatch workflows do not establish its audio, reminders, sleep controls,
+closed-panel notifications or VR panel. The real Frame exercise used the
+repository sample, not an official plugin. No wearer confirmation was
+available. Physical controller use, optical readability, official-plugin
+VR rendering, audible output and the VR keyboard remain unverified. The
+hourly shared-lock worn-check schedule stays enabled.
@@ -0,0 +1,44 @@
+# v0.4.46 candidate gate, 26 October 2026
+
+This candidate includes merged Free Loader PR #325, the Decky user-tool PATH
+fix (#323), and the interactive worn-check proximity gate (#324).
+The official 116-plugin catalog is **4 works / 50 partial / 51 broken /
+11 N/A**. Free Loader is partial for its verified package, local frontend
+and isolated settings/empty-deals scope. No live feed or worn-VR claim follows.
+
+## Locked real Frame smoke before the version bump
+
+At 12:12 UTC, source commit `21b85ba99dfd742a56e2c20259f56f35d83590fc`
+ran `scripts/frame-smoke.sh` on the real Frame under a unique owner of
+`/tmp/frame-test.lock`. Locked preflight found SteamVR activity **3**
+(standby), proximity raw **3.0** and battery **100%** on Frame OS 0.5.6 build
+`20261022.6153909`. Test-owned ARM64 and Windows/Proton titles installed,
+launched and were removed. The optional x86_64 title installed and was
+removed; launch was **skipped** because Steam Linux Runtime 4 is absent.
+The result was **12 passed / 1 skipped / 0 failed**. Cleanup passed and the
+command exited 0, which includes release of its owned lock. The detailed
+result remains private at
+`tests/smoke/results/2026-10-26T121228Z-20261022.6153909.json` in the
+candidate checkout.
+
+This smoke checks release plumbing and temporary titles, not an installed
+official Decky plugin. No wearer was confirmed. The interactive worn-check
+script was not run, and no headset wake or controller input was sent. Free
+Loader's actual ARM64 Decky backend, live feeds, panel visibility to a wearer,
+physical controllers, keyboard and optical comfort remain unverified. The
+hourly worn-headset check stays enabled.
+
+## Publication boundary
+
+At 12:17 UTC, exact version-bumped candidate commit
+`9aff6adcec71852ce9bedf0ae37364bd32bb6627` ran the same locked
+`scripts/frame-smoke.sh`. Preflight again found activity **3** standby,
+proximity raw **3.0** and battery **100%**. The result was **12 passed /
+1 optional x86 launch skipped / 0 failed**. Owned title/process cleanup
+passed and the command exited 0 after releasing its lock. Its private result
+is `tests/smoke/results/2026-10-26T121721Z-20261022.6153909.json` in the
+candidate checkout. This paragraph is the only change after that smoke.
+
+Green release-PR and post-merge CI, tagged installer build, all ten installer
+digests with `SHA256SUMS`, independent package checks, publisher dry run and
+public `update.json` readback remain required before publication.
@@ -0,0 +1,58 @@
+# v0.4.46 tagged release, 26 October 2026
+
+[PR #326](https://github.com/saphid/frame-control/pull/326) passed every required
+check on exact head `fc978a2afdfa47e60477fcb0bb573e7b6181fa89` and merged
+at 12:31:06 UTC. Main became `f84a4da9b1ae938d15b658af17903c0e10a56e94`.
+All seven jobs in the [post-merge main run](https://github.com/saphid/frame-control/actions/runs/40323149126)
+passed, including iOS and fake-Frame e2e. The app and lockfile both say
+`0.4.46`. Annotated tag `v0.4.46` dereferences to that main commit. The
+[tagged release workflow](https://github.com/saphid/frame-control/actions/runs/40324176903)
+passed its draft, Linux, Windows, Apple Silicon Mac, Intel Mac and checksum jobs.
+
+## Frame and package gates
+
+The [candidate evidence](v0446-candidate-2026-10-26.md) records a locked
+exact-version real Frame smoke: **12 passed / 1 optional x86 launch skipped /
+0 failed**, with owned cleanup and lock release. The x86 launch needs Steam
+Linux Runtime 4, which was absent. A separate 12:25 UTC read-only check acquired
+and released its own `/tmp/frame-test.lock`; SteamVR activity was **3**
+(standby), proximity raw **3.0**, and battery **100%**. No wearer was confirmed,
+so no wake, controller input or interactive worn-check script ran.
+
+The draft contained exactly ten installers plus `SHA256SUMS`, each with a
+GitHub SHA-256 digest. A fresh downloaded checksum file matched the ten digest
+lines regenerated from GitHub metadata byte for byte; its digest was
+`365e7f6d9549ff993162964920a6560480069ed04ce1eca5551696ce7bbc4ae8`.
+`scripts/publish-release.sh --dry-run v0.4.46` passed the exact tag, installer,
+checksum and update-manifest gates after release notes were attached.
+
+Independent downloads passed these checks:
+
+| Package | Result |
+| --- | --- |
+| Linux x86_64 AppImage | SHA-256 `65f66f1bbb5908d49c179307950f93b643c2b8da8ac4da48a778c5c9bac5d41b`; launched under isolated Xvfb, bundled server returned HTTP 200 with `FrameControl/1`, then stopped. |
+| Mac arm64 ZIP | SHA-256 `9af88f75db7936472590022ca03a03da9de4f91de7b35c5d4d130b6dc78ab4b5`; ZIP CRC valid, bundle version 0.4.46, main Mach-O CPU arm64. |
+| Mac x64 ZIP | SHA-256 `28d9ac00c9c918a7cb9f2caac54505faa8a953285bb40f82e02d9233b775d37a`; ZIP CRC valid, bundle version 0.4.46, main Mach-O CPU x86_64. |
+| Windows x64 Setup | SHA-256 `68e303dcabb2c82ba5b9a5a58bace2ca8154f9645f1da2214ca4c6dbb05f157d`; PE/Nullsoft installer format. Tagged Windows CI checked packaged files and Python libraries. |
+| Linux arm64 DEB | SHA-256 `da9b00bd44ca7a91c542df26d8c5711ad564d618add34f89aef946785c0bd538`; package version 0.4.46 and architecture arm64. |
+
+Tagged Mac and Windows packages were not launched on physical machines during
+this release gate. Earlier physical Intel Mac acceptance covers older bytes.
+
+## Publication and limits
+
+`scripts/publish-release.sh v0.4.46` published
+[v0.4.46](https://github.com/saphid/frame-control/releases/tag/v0.4.46) at
+12:48:03 UTC. GitHub's latest-release API returned the expected tag,
+`draft=false`, `prerelease=false`, ten installers, `SHA256SUMS` and
+`update.json`. A fresh public latest-download of `update.json` reported
+version 0.4.46, the stable release page, ten hashed installers and the
+worn-VR limit in its notes.
+
+The exact-version official catalog is **4 works / 50 partial / 51 broken /
+11 N/A** out of 116. Free Loader is partial for package, local frontend and
+isolated settings/empty-deals evidence. Its actual ARM64 Decky load, live
+feeds and notifications remain unverified. The real Frame was in standby;
+official-plugin wearer visibility, physical controller usability, keyboard
+and optical comfort remain unverified. The hourly shared-lock worn check stays
+enabled.
@@ -0,0 +1,46 @@
+# v0.4.47 candidate gate, 26 October 2026
+
+This candidate contains Game Theme Music's locally rendered Settings view
+(#330) and a digest-scoped Python import module for the official Shotty 0.1.0
+archive (#331). The 116-plugin table is **4 works / 52 partial / 49 broken /
+11 N/A**. Game Theme Music is partial for its local Settings view; its
+backend, network and playback were denied in that audit. Shotty is partial
+for its local frontend and synthetic screenshot copy in isolated Python;
+actual ARM64 Decky startup and live screenshot rescue are unverified.
+
+## Locked Frame candidate smoke
+
+At 14:18 UTC, source commit `1f5b37a7552880b40868617ef22398fcd39b3f5d`
+ran `scripts/frame-smoke.sh` on the real Frame. The script acquired its unique
+owner in `/tmp/frame-test.lock` before reading status. Locked preflight found
+SteamVR activity **3** (standby), proximity raw **3.0625**, and battery
+**100%** on Frame OS 0.5.6 build `20261022.6153909`. Owned ARM64 and
+Windows/Proton test titles installed, launched, and were removed. The
+optional x86_64 title installed and was removed; launch was **skipped**
+because Steam Linux Runtime 4 was absent. The result was **12 passed /
+1 skipped / 0 failed**. Cleanup passed and the command exited 0, including
+release of its owned lock. Detailed results stay private in
+`tests/smoke/results/2026-10-26T141812Z-20261022.6153909.json`.
+
+No wearer was confirmed. The interactive worn-check script was not run;
+the smoke did not wake the headset or test the Framey panel. Game Theme
+Music playback, Shotty live rescue, wearer-visible official-plugin UI,
+physical controllers, keyboard and optical comfort remain unverified.
+The hourly shared-lock worn check remains enabled.
+
+## Publication boundary
+
+At 14:23 UTC, the exact version-bumped candidate commit
+`e07fa155928d1609304e317d15e0c4ef4a977579` ran the same token-locked
+`scripts/frame-smoke.sh`.
+Preflight again found activity **3** (standby), proximity raw **3.0625** and
+battery **100%**. The result was **12 passed / 1 optional x86 launch skipped /
+0 failed**. Owned cleanup passed and the command exited 0 after releasing its
+lock. Its private result is
+`tests/smoke/results/2026-10-26T142321Z-20261022.6153909.json`.
+This paragraph is the only change after that smoke.
+
+PR #331's combined-head CI, green release-PR and post-merge CI, tagged
+installer builds, all ten installer digests with `SHA256SUMS`, independent
+package checks, publisher dry run, and public `update.json` readback remain
+required.
@@ -0,0 +1,62 @@
+# v0.4.47 tagged release, 26 October 2026
+
+The release PR [#332](https://github.com/saphid/frame-control/pull/332)
+passed its exact-head checks and all four installer preview jobs, including
+Intel Mac. It merged at main commit
+`035c59ee1134aa158c3cd818e8dd35f822cbfc4b`. The seven-job post-merge
+main [checks run](https://github.com/saphid/frame-control/actions/runs/40342375912)
+passed, including iOS and fake-Frame e2e. Annotated tag `v0.4.47`
+dereferences to that main commit. The tagged
+[release workflow](https://github.com/saphid/frame-control/actions/runs/40344549980)
+passed its draft, Linux, Windows, Apple Silicon Mac, Intel Mac, and checksum
+jobs.
+
+## Frame and package gates
+
+The [candidate evidence](v0447-candidate-2026-10-26.md) records a locked
+exact-version real Frame smoke: **12 passed / one optional x86 launch skipped /
+zero failed**, with owned cleanup and lock release. The x86 launch needs Steam
+Linux Runtime 4, which was absent. The headset was in standby and no wearer was
+confirmed, so the interactive worn-check script was not run. No panel or
+physical-controller claim follows from the smoke.
+
+The draft contained exactly ten installers and `SHA256SUMS`, each with a
+GitHub SHA-256 digest. An independently downloaded `SHA256SUMS` matched a
+fresh ten-line list regenerated from GitHub asset metadata byte for byte;
+its SHA-256 was
+`ab1a95e5d51333dfc962723a21b044da935e07c24cedbd430222dc482d725508`.
+`scripts/publish-release.sh --dry-run v0.4.47` passed the tag, installer,
+checksum, and update-manifest gates after release notes were attached.
+
+Independent downloads passed these checks:
+
+| Package | Result |
+| --- | --- |
+| Linux x86_64 AppImage | SHA-256 `e7c83cf9177d11de724caf40a829b5c97ac3d2f0a04df24bcb1e4107310f1f49`; launched under isolated Xvfb on lxso1, bundled server returned HTTP 200 with `FrameControl/1`, then stopped. |
+| Mac arm64 ZIP | SHA-256 `10092131b7fd43950e0dc436a51da1e41b42803d532a89363e2b71880b92b212`; ZIP CRC valid, bundle version 0.4.47, main Mach-O CPU arm64. |
+| Mac x64 ZIP | SHA-256 `24531b088e85d2e7e9174289b0b9532c78fb85e7a29775c24369c00bc61e5408`; ZIP CRC valid, bundle version 0.4.47, main Mach-O CPU x86_64. |
+| Windows x64 Setup | SHA-256 `a697a7e9042eb0d9545d99639e39ff53fbf993491c0728f59f038f21175b77cc`; PE/Nullsoft installer format. Tagged Windows CI checked packaged files and Python libraries. |
+| Linux arm64 DEB | SHA-256 `e0be95ffc714e71487889a7da4886676b75c993f86bb674d180dc3ea4cd4b3b6`; package version 0.4.47 and architecture arm64. |
+
+The tagged Mac and Windows packages were not launched on physical machines
+in this release gate. Earlier physical Intel Mac acceptance covers older
+bytes.
+
+## Publication and limits
+
+`scripts/publish-release.sh v0.4.47` published
+[v0.4.47](https://github.com/saphid/frame-control/releases/tag/v0.4.47) at
+15:07:28 UTC. GitHub's latest-release API returned that tag with
+`draft=false`, `prerelease=false`, ten installers, `SHA256SUMS`, and
+`update.json`. A fresh public latest-download of `update.json` reported
+version 0.4.47, the stable release page, ten hashed installers, and the
+worn-VR limit in its notes.
+
+The exact-version official catalog is **4 works / 52 partial / 49 broken /
+11 N/A** out of 116. Game Theme Music has a local Settings view; its music
+playback and live backend are unverified. Shotty's backend imported and
+copied a synthetic screenshot in isolated Python; live ARM64 Decky loading
+and screenshot rescue are unverified. The real Frame was in standby;
+official-plugin wearer visibility, physical controller usability, VR
+keyboard, and optical comfort remain unverified. The hourly shared-lock
+worn check remains enabled.
@@ -0,0 +1,50 @@
+# v0.4.48 candidate gate, 26 October 2026
+
+This candidate contains the exact-archive Music Control 1.1.7 Python call
+repair from [#335](https://github.com/saphid/frame-control/pull/335). All
+**11** hosted checks passed on its head
+`ff465accc508e40158c590eebffd4aec924503ac`, including fake-Frame e2e,
+Windows, macOS, Linux, ARM64 host libraries and iOS. The catalog remains
+**4 works / 52 partial / 49 broken / 11 N/A** out of 116. Music Control is
+partial: an isolated D-Bus command fixture proves dispatch after the repair;
+a live player and actual Decky ARM64 backend were not tested.
+
+## Locked real Frame smoke
+
+At 15:36 UTC, source head `ff465accc508e40158c590eebffd4aec924503ac`
+ran `scripts/frame-smoke.sh` on SteamOS 0.5.6 build `20261022.6153909`.
+The runner acquired its own unique `/tmp/frame-test.lock` owner before
+reading device status. Preflight found SteamVR activity **3** (standby),
+proximity raw **3.0625**, and battery **99%**. Owned ARM64 and Windows/Proton
+titles installed, launched and were removed. The optional x86_64 title
+installed and was removed; its launch was **skipped** because Steam Linux
+Runtime 4 was absent. The result was **12 passed / 1 skipped / 0 failed**.
+Owned cleanup passed and the command exited 0, including lock release.
+A separate fresh locked read found battery **100%**, activity **3** and no
+`fc_smoke_*` title directories; it released only its own lock. The private
+runner result is `2026-10-26T153655Z-20261022.6153909.json`.
+
+At 15:42 UTC, exact version-bumped commit
+`a31b4a426cf4204e45fe218e204a26328aa0b1c9` ran the same token-locked
+smoke. Preflight found activity **3**, proximity raw **3.0625** and battery
+**100%**. It passed **12 / 1 optional x86 launch skipped / 0 failed**.
+Cleanup passed and the command exited 0 after releasing its lock. The
+private runner result is `2026-10-26T154258Z-20261022.6153909.json`.
+A fresh separately locked read found battery **100%**, activity **3** and
+no test-title directories, then released that lock. Merging current main
+into the candidate created commit
+`a8bf01d660cd9abb8d2a724626a06a0e7e6c2a6a`; its tree before this
+evidence document was byte-identical to the tested version-bumped commit
+(`d45c2465ddfcf877fe2c8bc30420d4719da5035e`).
+
+No wearer was confirmed. Neither smoke woke the headset or ran the
+interactive worn-check script. Official-plugin wearer visibility, physical
+controllers, VR keyboard and optical comfort remain unverified. The hourly
+shared-lock worn check remains enabled.
+
+## Remaining publication gates
+
+The release PR's exact-head CI and installer previews, post-merge main CI,
+tagged builds with all ten installers and `SHA256SUMS`, independent package
+checks, publisher dry run and public `update.json` readback are required
+before publication.
@@ -4,7 +4,7 @@ Snapshot: 2026-10-26T06:10:58.537029+00:00; 116 current visible official plugins

 This table and both store views use [`ui/framey-compatibility.json`](../ui/framey-compatibility.json). Results apply only to the exact store ID, version and SHA-256. A changed digest/version is **unverified**. Regenerate this document with `python3 scripts/framey-compatibility-doc.py`; use `--check` in review.

-**Works: 4 · Partial: 49 · Broken: 52 · N/A: 11.**
+**Works: 4 · Partial: 52 · Broken: 49 · N/A: 11.**

 - **Works** requires verified useful plugin behavior with its real backend. Read the reason for the verified scope and remaining limits; it does not imply worn-VR verification.
 - **Partial** means only a subset or a local fixture scope was verified, often just frontend/settings initialization. The remaining backend/device functionality is unverified; read the reason for the exact scope.
@@ -25,9 +25,11 @@ python3 scripts/framey-audit-browser.py --cache /tmp/framey-archives

 Open the browser audit URL in local Chromium, run `runAudit()` and inspect/download `results`. All backend/network actions remain denied.

+A [Free Loader duplicate-entry follow-up](evidence/framey-free-loader-duplicates-2026-10-26.md) accepts only byte-identical duplicate ZIP members whose modes differ at most in execute bits. The exact archive passed private local and focused fake-Frame install/remove; its frontend rendered in opaque Chromium and isolated Python settings/empty-deals reads passed with a Decky stub. The earlier full 116-plugin fake-Frame audit blocked this archive before the fix. Actual Decky, feed updates and worn VR remain unverified.
+
 The current published digests are pinned in the JSON; if the store changed, retain/download those exact archives for reproduction. Audit downloads permit larger ZIPs for inspection; production installer limits remain 50 MiB ZIP / 150 MiB unpacked / 30 MiB per member.

-After the VR job released the shared lock, this audit acquired it and used a private temporary Decky 3.3.0 ARM64 user service. Read-only ProtonDB `get_setting` and Steam Status `get_settings` calls succeeded through the live Steam CEF websocket. The service and private base were removed and the lock released; normal managed services stayed inactive, battery was 100 → 99, and no power setting was changed. [Redacted results](evidence/framey-official-backend-2026-10-25.json) record exactly what ran. A [2026-10-26 follow-up](evidence/framey-events-backend-2026-10-26.json) verified default Notebook drawing/save/reopen across a real backend restart and Simple Timer start/cancel, countdown/completion events, a visible toast and persisted recents/subtle mode. Only private test settings were written. Simple Timer remains partial because its own expired-timer startup raises a missing `timer_task` error; sound/suspend are unsupported. A [local audio follow-up](evidence/framey-audio-backends-2026-10-26.md) exercised Volume Mixer, Volume Boost and Mixer through real Decky 3.3.0 amd64 backends on private silent virtual audio targets. Sliders, numeric volume entry, independent server readbacks and Mixer filter persistence across a runtime restart passed. An [ARM64 audio follow-up](evidence/framey-audio-arm64-2026-10-26.md) verified the unmodified official backends in actual Decky 3.3.0 on the Frame user audio session. Volume Mixer and Mixer now qualify as works for per-app volume: Chromium controls changed only a named silent stream, with independent Pulse readbacks. That run left Volume Boost partial because sink writes were denied. A [Volume Boost follow-up](evidence/framey-volume-boost-arm64-2026-10-26.md) now verifies linked/separate channel controls, re-link and reopen through the actual ARM64 backend. Independent Pulse reads confirmed 125%/150% gain writes while the default sink stayed muted; exact original volume/mute was restored. Volume Boost qualifies as works for sink controls. Audible output, Bluetooth playback and worn VR remain unverified. A [running-context follow-up](evidence/framey-running-context-2026-10-26.md) supplies detached running-app/main-app reads and relays actual Steam lifetime callbacks while a panel is open. Real Frame checks verified an empty list, registration/cleanup and the exact Discord Status ARM64 backend reporting no IPC connection. Nonempty games and transitions were synthetic fixtures; real game events, Discord activity and worn VR remain unverified. Discord Status moves to partial; no new works claim is made. A [library context follow-up](evidence/framey-library-context-2026-10-26.md) read 1,106 app overviews, 895 game IDs and the current public Steam ID from real Frame CEF under the shared lock. Local Chromium replayed this detached snapshot to render Deck Settings game selection, Steamback's empty save panel and PlayTime statistics/settings. Steamback and PlayTime used actual Decky 3.3.0 amd64 backends in an isolated container; their ARM64 backends and automatic game hooks remain unverified. Shotty's frontend now starts, but its published backend fails on missing `click`; it stays broken. A [chunked frontend follow-up](evidence/framey-deck-shelves-browser-2026-10-26.md) loaded Deck Shelves 2.0.0 through a managed JavaScript module route and rendered its settings in an opaque local Chromium panel. Its backend was denied; Steam Home shelves and worn VR remain unverified. A [local module lookup follow-up](evidence/framey-module-lookup-2026-10-26.md) supplies a finite registry of Framey-local controls and CSS. TabMaster QAM/docs now render; Steam library-tab editing remains unavailable. That pass exposed Junk-Store executable-script extraction failures; the follow-up below repairs them. SteamGridDB still requires Steam context-menu internals and DeckSP still fails its published MobX fallback. That pass tested TabMaster/Junk-Store in actual isolated amd64 Decky, without ARM64 or worn-VR coverage. A [script entrypoint follow-up](evidence/framey-script-entrypoints-2026-10-26.md) grants owner execute to shebang scripts and ZIP-declared executables without copying archive privilege/write bits. Junk-Store now passes static menu/backend calls in actual Decky 3.3.0 ARM64 and local Chromium Games/Epic navigation, back and reopen. It moves to partial: About still crashes on missing installed-app metadata, Legendary is absent, and login/game operations remain unverified. Existing installations require update/reinstall to repair permissions. A [read-only installed-metadata follow-up](evidence/framey-installed-context-2026-10-26.md) now repairs the About crash. The library snapshot copies only Steam-supplied installed booleans into detached metadata, preserving unknown values as undefined. Junk-Store About/Dependencies, Back and reopen render in local Chromium with actual Frame library data and the official ARM64 backend. It remains partial: dependency/login/game operations, RSS, the optional Line truncated
+After the VR job released the shared lock, this audit acquired it and used a private temporary Decky 3.3.0 ARM64 user service. Read-only ProtonDB `get_setting` and Steam Status `get_settings` calls succeeded through the live Steam CEF websocket. The service and private base were removed and the lock released; normal managed services stayed inactive, battery was 100 → 99, and no power setting was changed. [Redacted results](evidence/framey-official-backend-2026-10-25.json) record exactly what ran. A [2026-10-26 follow-up](evidence/framey-events-backend-2026-10-26.json) verified default Notebook drawing/save/reopen across a real backend restart and Simple Timer start/cancel, countdown/completion events, a visible toast and persisted recents/subtle mode. Only private test settings were written. Simple Timer remains partial because its own expired-timer startup raises a missing `timer_task` error; sound/suspend are unsupported. A [local audio follow-up](evidence/framey-audio-backends-2026-10-26.md) exercised Volume Mixer, Volume Boost and Mixer through real Decky 3.3.0 amd64 backends on private silent virtual audio targets. Sliders, numeric volume entry, independent server readbacks and Mixer filter persistence across a runtime restart passed. An [ARM64 audio follow-up](evidence/framey-audio-arm64-2026-10-26.md) verified the unmodified official backends in actual Decky 3.3.0 on the Frame user audio session. Volume Mixer and Mixer now qualify as works for per-app volume: Chromium controls changed only a named silent stream, with independent Pulse readbacks. That run left Volume Boost partial because sink writes were denied. A [Volume Boost follow-up](evidence/framey-volume-boost-arm64-2026-10-26.md) now verifies linked/separate channel controls, re-link and reopen through the actual ARM64 backend. Independent Pulse reads confirmed 125%/150% gain writes while the default sink stayed muted; exact original volume/mute was restored. Volume Boost qualifies as works for sink controls. Audible output, Bluetooth playback and worn VR remain unverified. A [running-context follow-up](evidence/framey-running-context-2026-10-26.md) supplies detached running-app/main-app reads and relays actual Steam lifetime callbacks while a panel is open. Real Frame checks verified an empty list, registration/cleanup and the exact Discord Status ARM64 backend reporting no IPC connection. Nonempty games and transitions were synthetic fixtures; real game events, Discord activity and worn VR remain unverified. Discord Status moves to partial; no new works claim is made. A [library context follow-up](evidence/framey-library-context-2026-10-26.md) read 1,106 app overviews, 895 game IDs and the current public Steam ID from real Frame CEF under the shared lock. Local Chromium replayed this detached snapshot to render Deck Settings game selection, Steamback's empty save panel and PlayTime statistics/settings. Steamback and PlayTime used actual Decky 3.3.0 amd64 backends in an isolated container; their ARM64 backends and automatic game hooks remain unverified. Shotty's frontend now starts, but its published backend fails on missing `click`; it stays broken. A [chunked frontend follow-up](evidence/framey-deck-shelves-browser-2026-10-26.md) loaded Deck Shelves 2.0.0 through a managed JavaScript module route and rendered its settings in an opaque local Chromium panel. Its backend was denied; Steam Home shelves and worn VR remain unverified. A [local module lookup follow-up](evidence/framey-module-lookup-2026-10-26.md) supplies a finite registry of Framey-local controls and CSS. TabMaster QAM/docs now render; Steam library-tab editing remains unavailable. That pass exposed Junk-Store executable-script extraction failures; the follow-up below repairs them. SteamGridDB still requires Steam context-menu internals and DeckSP still fails its published MobX fallback. That pass tested TabMaster/Junk-Store in actual isolated amd64 Decky, without ARM64 or worn-VR coverage. A [script entrypoint follow-up](evidence/framey-script-entrypoints-2026-10-26.md) grants owner execute to shebang scripts and ZIP-declared executables without copying archive privilege/write bits. Junk-Store now passes static menu/backend calls in actual Decky 3.3.0 ARM64 and local Chromium Games/Epic navigation, back and reopen. It moves to partial: About still crashes on missing installed-app metadata, Legendary is absent, and login/game operations remain unverified. Existing installations require update/reinstall to repair permissions. A [read-only installed-metadata follow-up](evidence/framey-installed-context-2026-10-26.md) now repairs the About crash. The library snapshot copies only Steam-supplied installed booleans into detached metadata, preserving unknown values as undefined. Junk-Store About/Dependencies, Back and reopen render in local Chromium with actual Frame library data and the official ARM64 backend. It remains partial: dependency/login/game operations, RSS, the optional Line truncated

 ## Every current plugin

@@ -59,21 +61,21 @@ The API column shows manifest / actual bundled frontend API. Many manifests say
 | 37: Discord Status 1.5.0 | 1 / 2 | partial | Disconnected panel renders; running-activity construction accepts a synthetic game in local Chromium. Exact official is_connected returned false in real Decky 3.3.0 ARM64. Empty live running-list reads and lifetime registration/cleanup passed. Real game transitions, Discord shortcut detection/connection/activity, local custom artwork and worn VR remain unverified/unsupported. | static archive, local browser, fake-Frame, real Frame SSH |
 | 38: Volume Mixer 1.2.1-1 | legacy / legacy | works | Per-app stream discovery and slider/keyboard volume changes pass in local Chromium through real Decky 3.3.0 ARM64 on the Frame audio session, with independent Pulse readback of a silent test stream. Bluetooth playback, audible output and worn-VR controls unverified. | static archive, local browser, fake-Frame, isolated Linux backend, real Frame SSH |
 | 40: Controller Tools 2.0.2 | 1 / 2 | broken | Plugin contains a non-ARM64 Linux binary: ControllerTools/bin/backend. Frontend audit failed: Audit blocks WebSocket. | static archive, local browser, fake-Frame |
-| 43: Tailscale Control 0.1.3 | legacy / legacy | partial | Settings render locally after the SuspensefulImage fallback. Tailscale daemon/state, connection and exit-node changes unverified; bundled localhost QR asset remains unavailable. No network settings were changed. | static archive, local browser, fake-Frame |
+| 43: Tailscale Control 0.1.3 | legacy / legacy | partial | Settings render locally after the SuspensefulImage fallback. On the real Frame, exact official read-only backend status calls returned live state, exit-node and device entries when ~/.local/bin was in PATH; a transient user unit found the CLI with the proposed managed-service PATH. Live Framey Decky RPC, connection/exit-node changes and worn VR remain unverified; the bundled localhost QR asset is unavailable. No network settings were changed. | static archive, local browser, fake-Frame, real Frame read-only backend |
 | 44: DeckMTP 1.0.5 | legacy / legacy | broken | Plugin contains a non-ARM64 Linux binary: DeckMTP/bin/umtprd. | static archive, local browser, fake-Frame |
 | 46: Steamback 1.0.0-1 | legacy / legacy | partial | Panel opens using the real Frame current-user/library snapshot. Account setup and empty save-list reads pass through actual Decky 3.3.0 amd64 in isolation. ARM64 backend, supported-save discovery, automatic backups and restore remain unverified; no backup/restore ran. | static archive, local browser, fake-Frame, real Frame SSH |
 | 48: Quick Launch 1.2.1 | legacy / legacy | broken | This plugin needs root and is not supported by the Frame user service. | static archive, local browser, fake-Frame |
 | 49: Decky Cloud Save 1.4.2 | legacy / legacy | broken | Unsafe plugin archive member. | static archive, local browser, fake-Frame |
 | 50: Storage Cleaner 1.4.0 | 1 / 2 | partial | Empty-data panel rendered; cleanup was deliberately not run because it can remove local data. | static archive, local browser, fake-Frame |
-| 52: Game Theme Music 1.7.1-1 | 1 / 2 | broken | Frontend audit failed: Cannot read properties of null (reading 'type'). | static archive, local browser, fake-Frame |
-| 53: Shotty 0.1.0 | legacy / legacy | broken | Library snapshot fixes the frontend allApps crash. Actual published Decky 3.3.0 amd64 backend fails importing click.get_app_dir (ModuleNotFoundError); the archive does not bundle click. Screenshot aggregation/rescue was not run. | static archive, local browser, fake-Frame, real Frame SSH |
+| 52: Game Theme Music 1.7.1-1 | 1 / 2 | partial | An inert local component lets the exact frontend initialize and render its Settings view in opaque Chromium. Backend get_setting and plugin network were denied in the audit; Steam game-page theme injection has no verified target in Framey. Music search, playback, downloads, settings persistence and worn VR remain unverified. | static archive, local browser, fake-Frame |
+| 53: Shotty 0.1.0 | legacy / legacy | partial | The frontend starts with the read-only Frame library snapshot. Frame Control adds a digest-scoped click.get_app_dir compatibility module to the managed install; the exact backend then imports and copies a synthetic Steam screenshot into a temporary Pictures folder in isolated Python. Actual Decky 3.3.0 ARM64 loading, live screenshots/rescue, in-VR panel and physical controller use remain unverified. | static archive, local browser, fake-Frame, real Frame SSH, isolated Python backend |
 | 56: MangoPeel 0.0.7 | 1 / 2 | partial | Initializer succeeds; gamescope/MangoHud actions and backend are unverified. | static archive, local browser, fake-Frame |
 | 58: Volume Boost 0.0.7 | legacy / legacy | works | Default-sink controls pass in local Chromium through real Decky 3.3.0 ARM64: linked slider/keyboard and numeric writes, separate channels, re-link and reopen, with independent Pulse readback including 125%/150% while muted. Exact original volume/mute restored. Audible output, Bluetooth sinks and worn VR unverified. | static archive, local browser, fake-Frame, isolated Linux backend, real Frame SSH |
 | 59: Web Browser 1.4.3 | legacy / legacy | broken | The exact frontend now initializes with a null Steam React-root lookup. The browser itself still requires Steam GamepadUI CDP injection and a backend WebSocket unavailable in Framey; no working browser tab was verified. | static archive, local browser, fake-Frame, focused local browser |
 | 60: DeckyFileServer 1.2.0 | 1 / 2 | broken | Plugin contains a non-ARM64 Linux binary: DeckyFileServer/bin/backend. | static archive, local browser, fake-Frame |
 | 61: TabMaster 2.15.1 | 1 / 2 | partial | Local Chromium rendered the QAM and navigable Overview/Filters documentation with an actual Decky 3.3.0 amd64 backend. Library-tab editing remains unavailable: Steam login/library patches and MobX reactions have no target. ARM64 and worn VR unverified. | static archive, local browser, fake-Frame |
 | 62: TS3 QuickAccess 1.2.0 | legacy / legacy | broken | Plugin contains a non-ARM64 Linux binary: ts3-qs4sd/bin/ts3-qs4sd.so. | static archive, local browser, fake-Frame |
-| 63: Free Loader 1.6.0 | 1 / 2 | broken | Unsafe plugin archive member. | static archive, local browser, fake-Frame |
+| 63: Free Loader 1.6.0 | 1 / 2 | partial | The exact archive's duplicate names contain identical bytes and differ only in execute bits; the guarded installer now accepts them, and a private local install/remove transaction passed. The current opaque Chromium host renders Free Games but cannot load deals with backend/network denied. Exact official Python settings and empty local-deals methods passed in a no-network container with a Decky stub. Real Decky, feed refresh, notifications and worn VR remain unverified. | static archive, local browser, fake-Frame pinned install/remove, local exact-archive transaction, isolated Python backend |
 | 64: Syncthing 0.2.7 | legacy / legacy | broken | Plugin contains a non-ARM64 Linux binary: decky-syncthing/bin/decky-syncthing-watchdog. | static archive, local browser, fake-Frame |
 | 65: Decky Terminal 0.5.3 | 1 / 2 | partial | Local routes initialize after parameter-route support; no shell commands were run. | static archive, local browser, fake-Frame |
 | 66: PlayTime 3.2.5 | 1 / 2 | partial | Statistics and routed settings render with a detached real Frame library/user snapshot and actual Decky 3.3.0 amd64 backend in isolation. User selection and empty statistics reads pass. Running snapshots are now exposed, but its private MobX observation is unsupported; automatic recording and ARM64 backend remain unverified. | static archive, local browser, fake-Frame, real Frame SSH |
@@ -117,7 +119,7 @@ The API column shows manifest / actual bundled frontend API. Many manifests say
 | 108: HueSync 3.8.0 | 1 / 2 | N/A | Not supported on Frame: Targets handheld RGB/LED controllers (AYANEO/Ally/MSI), not Frame hardware. | static archive, local browser, fake-Frame |
 | 109: MuraDeck 2.1.4 | 1 / 2 | N/A | Not supported on Frame: Calibration is specifically for defective Samsung Steam Deck OLED panels, not Frame displays. | static archive, local browser, fake-Frame |
 | 110: Dimmer Deck 0.0.4 | 1 / 2 | N/A | Not supported on Frame: Changes gamescope/X11 dimming properties; no mapping to Frame VR display brightness exists. | static archive, local browser, fake-Frame |
-| 111: Music Control 1.1.7 | legacy / legacy | partial | Panel initializer succeeds with backend/network blocked; actual controls and backend remain unverified. | static archive, local browser, fake-Frame |
+| 111: Music Control 1.1.7 | legacy / legacy | partial | Exact official backend bound-method calls are repaired in managed installs. An isolated fake dbus-send target accepted player discovery, transport and volume commands after the patch; real MPRIS players, actual Decky ARM64, album art and worn VR remain unverified. | static archive, local browser, fake-Frame, isolated Python backend |
 | 112: Better Keyboard 0.3.4 | 1 / 2 | broken | This plugin needs root and is not supported by the Frame user service. Frontend audit failed: window.SteamClient.UI.GetUIMode is not a function. | static archive, local browser, fake-Frame |
 | 113: Decky LSFG-VK 0.12.2 | 1 / 2 | partial | Initializer succeeds; runtime LSFG/Windows DLL downloads and Vulkan integration are not ARM64-validated. | static archive, local browser, fake-Frame |
 | 114: Network Sentinel 1.0.4 | 1 / 2 | broken | This plugin needs root and is not supported by the Frame user service. | static archive, local browser, fake-Frame |
@@ -129,7 +131,7 @@ The API column shows manifest / actual bundled frontend API. Many manifests say
 | 120: Reroll 0.2.1 | 1 / 2 | broken | Frontend now initializes with inert game-action subscriptions, but the archive contains x86_64 memscan.so and requests root. No process-memory access was run. | static archive, local browser, fake-Frame |
 | 121: DeckPass 1.1.1 | 1 / 2 | partial | Initializer succeeds; KeePass Flatpak discovery and secrets integration were not exercised. | static archive, local browser, fake-Frame |
 | 123: Steam Status 1.2.3 | 2 / 2 | partial | Settings/public status rendered locally; cache errors fixed. Read-only get_settings RPC returned actual Decky 3.3.0 defaults on ARM64 Frame. Persistence, live backend diagnostics and VR controls unverified. | static archive, local browser, fake-Frame, real Frame SSH |
-| 124: AlarMe 1.6.3 | 1 / 2 | partial | Initializer succeeds; timers, reminders, suspend inhibition and audio are unverified. | static archive, local browser, fake-Frame |
+| 124: AlarMe 1.6.3 | 1 / 2 | partial | Silent labeled timer create/ticks/pause/cancel, preset save/cancel-confirm/delete and stopwatch start/lap/pause/reset/reopen pass in local Chromium with the official Decky 3.3.0 ARM64 backend. Audio, alarms/reminders, suspend inhibition, Steam overlays and worn VR remain unverified; notifications require the panel to stay open. | static archive, local browser, fake-Frame, real Frame SSH |
 | 125: Decky Localsend 0.4.5 | 1 / 2 | broken | Plugin contains a non-ARM64 Linux binary: decky-localsend/bin/localsend-core. | static archive, local browser, fake-Frame |
 | 126: Launch Options 1.9.2 | 1 / 2 | broken | Plugin contains a non-ARM64 Linux binary: decky-launch-options/bin/hello. Frontend audit failed: Cannot convert undefined or null to object. | static archive, local browser, fake-Frame |
 | 127: Decky Translator 0.9.0 | 1 / 2 | partial | Initializer succeeds; x86_64 download and hidraw/controller assumptions need an ARM64 audit. OCR/translation not exercised. | static archive, local browser, fake-Frame |
@@ -140,7 +142,7 @@ The API column shows manifest / actual bundled frontend API. Many manifests say
 | 132: SuggestMe 1.5.3 | 1 / 2 | partial | Initializer succeeds; recommendation backend and Steam library data unverified. | static archive, local browser, fake-Frame |
 | 133: Non-Steam Badges 0.1.0 | 1 / 2 | partial | Initializer succeeds; Non-Steam game badges have no supported Steam page injection target. | static archive, local browser, fake-Frame |
 | 134: Deck Progress Tracker 1.3.6 | 1 / 2 | partial | Initializer succeeds; Steam game/library statistics and page patches unverified. | static archive, local browser, fake-Frame |
-| 135: Deck Shelves 2.0.0 | 1 / 1 | partial | The exact chunked frontend now initializes and renders Deck Shelves settings in an opaque local Chromium panel. Backend calls were denied; Home-screen shelf injection has no verified Steam UI target in Framey. Settings writes, real backend behavior and worn VR are unverified. | static archive, local browser, fake-Frame |
+| 135: Deck Shelves 2.0.0 | 1 / 1 | partial | The exact chunked frontend renders settings in opaque local Chromium. The official Python backend saved a shelf and returned it after reopen with a stub Decky module and temporary settings directory. Actual Decky RPC, real Frame settings, Steam Home shelf injection and worn VR remain unverified. | static archive, local browser, fake-Frame, isolated Python backend |
 | 136: Decky-Clipper 1.0.2 | 1 / 2 | broken | Plugin contains a non-ARM64 Linux binary: Decky-Clipper/bin/gstreamer-1.0/libgstproxy.so. | static archive, local browser, fake-Frame |
 | 137: Decky Proton Launch 0.9.0 | 1 / 2 | partial | Initializer succeeds; Proton wrapper installation and launch changes were not run. | static archive, local browser, fake-Frame |
 | 138: Docky 1.4.13 | legacy / legacy | broken | This plugin needs root and is not supported by the Frame user service. | static archive, local browser, fake-Frame |
@@ -252,7 +254,7 @@ DFL includes exports imported through decky-frontend-lib / @decky/ui. Steam stor
 | Reroll | Apps.RegisterForGameActionUserRequest, GameSessions.RegisterForAppLifetimeNotifications, Settings.GetCurrentLanguage | ButtonItem, DialogButton, Field, Focusable, Marquee, ModalRoot, PanelSection, PanelSectionRow, SliderField, libraryAssetImageClasses, mainMenuAppRunningClasses, quickAccessMenuClasses, showModal | SteamUIStore, QAM/global tabs, Steam stores | Python + native payload; x86_64 | No specific hardware requirement detected statically; runtime requirements unverified. |
 | DeckPass | Apps.AddShortcut, Apps.RunGame, Apps.SetCustomArtworkForApp, Apps.SetShortcutExe, Apps.SetShortcutLaunchOptions, Apps.SetShortcutName, Input.ControllerKeyboardSendText | Button, ButtonItem, DialogButton, Field, Focusable, ModalRoot, PanelSection, PanelSectionRow, Router, TextField, findSP, showModal, sleep, staticClasses | Router, appDetailsStore, appStore, toaster, window.SP_REACT, toasts, Steam stores | Python | flatpak |
 | Steam Status | none detected | ButtonItem, ConfirmModal, DialogButton, Field, Focusable, Navigation, PanelSection, PanelSectionRow, SliderField, ToggleField, definePlugin, showModal, staticClasses | toaster, toasts | Python | No specific hardware requirement detected statically; runtime requirements unverified. |
-| AlarMe | GameSessions.RegisterForAppLifetimeNotifications | ButtonItem, ConfirmModal, Dropdown, Focusable, Navigation, PanelSection, PanelSectionRow, ProgressBarWithInfo, SidebarNavigation, SliderField, TextField, ToggleField, findModuleChild, showModal, staticClasses | routerHook, toaster, window.SP_REACT, local/Steam routes, toasts, QAM/global tabs, Steam page patches/module lookup | Python | No specific hardware requirement detected statically; runtime requirements unverified. |
+| AlarMe | GameSessions.RegisterForAppLifetimeNotifications | ButtonItem, ConfirmModal, Dropdown, Focusable, Navigation, PanelSection, PanelSectionRow, ProgressBarWithInfo, SidebarNavigation, SliderField, TextField, ToggleField, findModuleChild, showModal, staticClasses | routerHook, toaster, window.SP_REACT, local/Steam routes, toasts, QAM/global tabs, Steam page patches/module lookup | Python | Timers/stopwatch use Python. Optional sleep inhibition opens /dev/uinput; sound and auto-suspend are unverified. Steam game overlays have no target in the isolated panel. |
 | Decky Localsend | none detected | ButtonItem, DialogBody, DialogButton, DialogButtonPrimary, DialogFooter, DialogHeader, Field, Focusable, ModalRoot, Navigation, PanelSection, PanelSectionRow, Router, SidebarNavigation, TextField, ToggleField, showModal, staticClasses | Router, routerHook, toaster, local/Steam routes, toasts, Steam stores | Python + native payload; x86_64 | No specific hardware requirement detected statically; runtime requirements unverified. |
 | Launch Options | Apps.RegisterForAppDetails, Apps.SetAppLaunchOptions | ButtonItem, ConfirmModal, DialogBody, DialogButton, DialogButtonPrimary, DialogControlsSection, DialogControlsSectionHeader, DialogFooter, DialogHeader, Dropdown, Field, Focusable, MenuItem, ModalRoot, Navigation, PanelSection, PanelSectionRow, ScrollPanel, SidebarNavigation, SteamSpinner, Tabs, TextField, Toggle, ToggleField, afterPatch, createReactTreePatcher, fakeRenderComponent, findInReactTree, findInTree, findModule, findModuleByExport, showModal, staticClasses, useParams | SteamUIStore, routerHook, local/Steam routes, Steam page patches/module lookup, Steam stores | Python + native payload; x86_64 | flatpak; gamescope |
 | Decky Translator | User.RegisterForPrepareForSystemSuspendProgress | ButtonItem, DialogButton, Dropdown, DropdownItem, Field, Focusable, ModalRoot, Navigation, PanelSection, PanelSectionRow, Router, SliderField, Tabs, TextField, ToggleField, findModuleChild, showModal, staticClasses | Router, routerHook, toaster, window.SP_REACT, local/Steam routes, toasts, QAM/global tabs, Steam page patches/module lookup | Python | /dev/hidraw; /sys/class/hidraw/hidraw{i}; /sys/class/hidraw/hidraw{i}/device/uevent; x86_64 |
@@ -286,7 +288,7 @@ All published Linux native payloads in this snapshot are x86_64; no published aa
 | Fantastic | bin/backend | Fan backend/driver is Deck-specific; an ARM64 rebuild would not provide compatible Frame hardware. |
 | PowerTools | bin/libryzenadj.so, bin/ryzenadj, bin/backend | RyzenAdj and AMD power backend cannot control an ARM64 Frame SoC. |
 | Memory Deck | bin/libscanmem.so.1.0.0 | libscanmem must be rebuilt for aarch64 and validated against target process architecture; memory writes were not tested. |
-| Emuchievements | bin/hash | The bin/hash helper needs an ARM64 build and cross-platform hashing tests; no ARM64 artifact is published. |
+| Emuchievements | bin/hash | A source-matched ARM64 bin/hash helper matched the official x86_64 helper on one synthetic ROM on the real Frame (docs/evidence/framey-emuchievements-arm-2026-10-26.md). The official ZIP still bundles x86_64 bytes and remains blocked; format coverage, packaging, plugin backend/UI, login and worn VR are unverified. |
 | MoonDeck | python/externals/yarl/_quoting_c.cpython-313-x86_64-linux-gnu.so, python/externals/aiohttp/_http_parser.cpython-313-x86_64-linux-gnu.so, python/externals/aiohttp/_websocket/reader_c.cpython-313-x86_64-linux-gnu.so, python/externals/aiohttp/_websocket/mask.cpython-313-x86_64-linux-gnu.so, python/externals/aiohttp/_http_writer.cpython-313-x86_64-linux-gnu.so, … 26 total; full list in JSON | Rebuild vendored CPython 3.13 extension wheels for the headset Python ABI and ARM64; buddy/helper dependencies also need ports. |
 | Controller Tools | bin/backend | Native backend needs an ARM64 build and controller/HID dependencies; its direct websocket also bypasses the Framey bridge. |
 | DeckMTP | bin/umtprd | umtprd needs ARM64 libusb/MTP dependencies and USB gadget permissions; root user-service blocker remains. |
@@ -217,6 +217,10 @@ frontend cannot call the changing backend. Open panel is unavailable while a
 store job is pending. A later installed-status refresh also closes an open panel
 if Decky stopped, its store receipt changed, or the status read failed. Reopen
 the plugin after a successful refresh to use its current frontend.
+Chunked frontends load modules through URLs bound to the installed store
+receipt. If a desktop store update replaces the plugin during panel startup,
+old module requests fail and the panel must be reopened; Framey does not mix
+chunks from two installed versions.
 The headset also includes the panel's store SHA-256 receipt with each backend
 call, Steam read, and event poll. It rejects a request if the installed receipt
 changed before the next status refresh; reopen the panel to use the new version.
@@ -112,8 +112,10 @@ the same-plugin navigation regression without a headset.
   interaction window, use the physical controller to open the sample and
   toggle **Example setting**. Confirm the laser aims where expected and the
   script records a fresh input/panel event and visible stereo output. The flag
-   is the operator’s statement; sensor activity and trusted pointers can also
-   be produced synthetically and cannot identify controller hardware.
+   is the operator’s statement. The script requires valid locked SteamVR activity
+   and proximity readings before input; proximity alone cannot establish wear.
+   Sensor activity and trusted pointers can also be produced synthetically and
+   cannot identify controller hardware.
 3. **1:15–2:15:** Use the controller to open Settings, return to Panel, invoke
   **Read saved setting**, close/reopen the plugin, and confirm the value
   remains. Try controller scroll, a slider and a harmless text field in an
@@ -11,6 +11,7 @@ import io
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 import json
 from pathlib import Path
+import re
 import sys
 from unittest.mock import patch
 import zipfile
@@ -27,8 +28,45 @@ for(const key of ['error','warn']){const original=console[key];console[key]=(...
  report(key,args.map(String).join(' '));original(...args);};}
 window.fetch=()=>Promise.reject(Error('Audit blocks plugin network'));
 window.WebSocket=class{constructor(){throw Error('Audit blocks WebSocket');}};
+addEventListener('message', event=>{
+  if(event.source!==parent||event.data?.type!=='audit:inspect')return;
+  parent.postMessage({type:'audit:snapshot',text:(document.getElementById('framey-root')?.innerText||'').slice(0,2000)},'*');
+});
 </script>'''

+
+def render_panel(record, data):
+    if hashlib.sha256(data).hexdigest() != record['sha256']:
+        raise ValueError('Archive hash mismatch')
+    with zipfile.ZipFile(io.BytesIO(data)) as archive:
+        bundle = archive.read(record['folder']+'/dist/index.js')
+    # The audit supplies only digest-checked archive bytes, not an installed
+    # receipt. Stub the receipt-bound lookup while using the shipped renderer.
+    with patch.object(framey_panel, '_owned_dist', return_value=(None, bundle, record['sha256'])):
+        return framey_panel.panel(record['id']).replace(
+            b'<script id="framey-bundle"', PRELUDE.encode()+b'<script id="framey-bundle"')
+
+
+def read_module_asset(path, records, cache):
+    """Serve the same receipt-bound module URL shape as the installed panel."""
+    prefix = '/framey/module/'
+    if not path.startswith(prefix):
+        raise ValueError('Invalid module path')
+    parts = path[len(prefix):].split('/', 2)
+    if len(parts) != 3 or not re.fullmatch(r'[1-9][0-9]*', parts[0]):
+        raise ValueError('Invalid plugin ID')
+    plugin_id, receipt, name = parts
+    if not framey_panel.RECEIPT.fullmatch(receipt) or not framey_panel.MODULE_PATH.fullmatch(name):
+        raise ValueError('Invalid module receipt or path')
+    record = records[int(plugin_id)]
+    if receipt != record['sha256']:
+        raise ValueError('Plugin receipt changed')
+    data = (cache/(receipt+'.zip')).read_bytes()
+    if hashlib.sha256(data).hexdigest() != receipt:
+        raise ValueError('Archive hash mismatch')
+    with zipfile.ZipFile(io.BytesIO(data)) as archive:
+        return archive.read(record['folder']+'/dist/'+name)
+
 PAGE = '''<!doctype html><meta charset=utf-8><title>Framey catalog frontend audit</title>
 <h1>Framey catalog frontend audit</h1>
 <p>Exact archived frontend code runs in an opaque iframe. All backend calls and network requests are denied.
@@ -42,6 +80,7 @@ addEventListener('message',event=>{
  if(event.source!==panel.contentWindow||!active)return;
  const data=event.data;
  if(data.type==='audit:log'&&active.logs.length<8)active.logs.push({kind:data.kind,message:data.message.split('\\n')[0].slice(0,400)});
+  if(data.type==='audit:snapshot')active.rootText=String(data.text).slice(0,2000);
  if(data.type==='framey:error')active.error=String(data.message).slice(0,500);
  if(data.type==='framey:ready')active.ready=true;
  if(data.type==='framey:events')event.source.postMessage({type:'framey:reply',id:data.id,result:{events:[],cursor:0}},'*');
@@ -59,10 +98,15 @@ window.runAudit=async(ids,settleMs=1200)=>{
  if(!Number.isInteger(settleMs)||settleMs<1200||settleMs>10000)throw Error('Invalid audit settle time');
  if(running)throw Error('Audit already running');running=true;run.disabled=true;
  try{for(const plugin of plugins.filter(plugin=>!ids||ids.includes(plugin.id))){
-    active={id:plugin.id,name:plugin.name,ready:false,error:null,logs:[],methods:[],
+    active={id:plugin.id,name:plugin.name,ready:false,error:null,logs:[],methods:[],rootText:'',
      library:librarySnapshot?'snapshot replay':'unavailable',running:runningSnapshot?'snapshot replay':'unavailable'};
    progress.textContent=plugin.id+' '+plugin.name;panel.src='/panel/'+plugin.id;
-    await new Promise(resolve=>setTimeout(resolve,settleMs));results.push(active);active=null;
+    await new Promise(resolve=>setTimeout(resolve,settleMs));
+    // Detached Steam snapshots may contain personal library data. Keep text
+    // observations out of reports that replay either snapshot.
+    if(!librarySnapshot&&!runningSnapshot)panel.contentWindow.postMessage({type:'audit:inspect'},'*');
+    await new Promise(resolve=>setTimeout(resolve,80));
+    results.push(active);active=null;
    panel.src='about:blank';await new Promise(resolve=>setTimeout(resolve,30));
  }}finally{running=false;run.disabled=false;progress.textContent='Done: '+results.length;}
  return results;
@@ -116,27 +160,13 @@ def main():
                try:
                    record = records[int(path.split('/')[-1])]
                    data = (args.cache/(record['sha256']+'.zip')).read_bytes()
-                    if hashlib.sha256(data).hexdigest() != record['sha256']:
-                        raise ValueError('Archive hash mismatch')
-                    with zipfile.ZipFile(io.BytesIO(data)) as archive:
-                        bundle = archive.read(record['folder']+'/dist/index.js')
-                    with patch.object(framey_panel, 'local_bundle', return_value=bundle):
-                        body = framey_panel.panel(record['id']).replace(
-                            b'<script id="framey-bundle"', PRELUDE.encode()+b'<script id="framey-bundle"')
+                    body = render_panel(record, data)
                except (KeyError, ValueError, OSError, zipfile.BadZipFile):
                    self.send_error(404, 'Verified frontend archive unavailable')
                    return
            elif path.startswith('/framey/module/'):
                try:
-                    plugin_id, name = path.removeprefix('/framey/module/').split('/', 1)
-                    if not framey_panel.MODULE_PATH.fullmatch(name):
-                        raise ValueError('Invalid module path')
-                    record = records[int(plugin_id)]
-                    data = (args.cache/(record['sha256']+'.zip')).read_bytes()
-                    if hashlib.sha256(data).hexdigest() != record['sha256']:
-                        raise ValueError('Archive hash mismatch')
-                    with zipfile.ZipFile(io.BytesIO(data)) as archive:
-                        body = archive.read(record['folder']+'/dist/'+name)
+                    body = read_module_asset(path, records, args.cache)
                    content_type = 'text/javascript; charset=utf-8'
                    module_asset = True
                except (KeyError, ValueError, OSError, zipfile.BadZipFile):
@@ -40,6 +40,7 @@ def render(data):
        'python3 scripts/framey-audit-browser.py --cache /tmp/framey-archives',
        '```', '',
        'Open the browser audit URL in local Chromium, run `runAudit()` and inspect/download `results`. All backend/network actions remain denied.', '',
+        'A [Free Loader duplicate-entry follow-up](evidence/framey-free-loader-duplicates-2026-10-26.md) accepts only byte-identical duplicate ZIP members whose modes differ at most in execute bits. The exact archive passed private local and focused fake-Frame install/remove; its frontend rendered in opaque Chromium and isolated Python settings/empty-deals reads passed with a Decky stub. The earlier full 116-plugin fake-Frame audit blocked this archive before the fix. Actual Decky, feed updates and worn VR remain unverified.', '',
        'The current published digests are pinned in the JSON; if the store changed, retain/download those exact archives for reproduction. '
        'Audit downloads permit larger ZIPs for inspection; production installer limits remain 50 MiB ZIP / 150 MiB unpacked / 30 MiB per member.', '',
        'After the VR job released the shared lock, this audit acquired it and used a private temporary Decky 3.3.0 ARM64 user service. '
@@ -73,10 +74,16 @@ def render(data):
        'install folders and system information, plus IsThereAnyDeal\'s country dropdown in local Chromium. '
        'The installed-plugin status was fixture-shaped in that relay; plugin backends stayed denied and the deployed headset HTTP endpoint remains unverified. '
        'A [Web Browser frontend follow-up](evidence/framey-web-browser-2026-10-26.md) verified its exact archive now initializes with an inert null Steam React-root lookup. Its GamepadUI CDP/browser backend path remains unavailable, so it stays broken. '
+        'A [dialog and activation follow-up](evidence/framey-dialog-controls-2026-10-26.md) fixes DFL Focusable pointer/keyboard activation and confirmation descriptions, cancel/disabled actions, scoped close callbacks and nested dialogs. '
+        'AlarMe silent timer ticks/pause/cancel, private preset save/cancel-confirm/delete and stopwatch start/lap/pause/reset/reopen pass in local Chromium with its official Decky 3.3.0 ARM64 backend. '
+        'AlarMe stays partial: audio, alarms/reminders, sleep inhibition, Steam overlays and worn VR are unverified; notifications require the panel to remain open. '
        'Earlier focused checks cover [ProtonDB](evidence/framey-browser-2026-10-25.md), '
        '[Steam Status/cache](evidence/framey-cache-browser-2026-10-25.md), '
        '[Storage Cleaner](evidence/framey-api-v1-browser-2026-10-25.md), and '
-        '[legacy MusicControl](evidence/framey-legacy-2026-10-25.md).', '',
+        '[legacy MusicControl](evidence/framey-legacy-2026-10-25.md). '
+        'A [Music Control 1.1.7 backend follow-up](evidence/framey-music-control-bound-methods-2026-10-26.md) '
+        'repairs exact-archive bound-method calls and verifies transport/volume command dispatch against an isolated dbus-send fixture. '
+        'A real MPRIS player and actual ARM64 Decky backend remain unverified.', '',
        '## Every current plugin', '',
        'The API column shows manifest / actual bundled frontend API. Many manifests say v1 while their bundle connects API2. '
        'Missing manifest API is labelled legacy; an unrecognized bundle is unknown. Globals and hardware are static signals, not exhaustive dependencies.', '',
@@ -90,6 +90,15 @@ def settings(state):
    return pause, timeout


+def steamvr_activity(rows):
+    """Read the unique status row; metrics can precede it in --stats output."""
+    if not isinstance(rows, list):
+        return None
+    levels = [row.get('activity_level') for row in rows
+              if isinstance(row, dict) and row.get('operation') == 'status']
+    return levels[0] if len(levels) == 1 and type(levels[0]) is int else None
+
+
 def diagnostic_source():
    return (ROOT / 'scripts/framey_openvr.py').read_text() + '''
 import json
@@ -183,9 +192,7 @@ def main(argv=None):
        if not before['battery'] or min(before['battery']) < 20:
            raise RuntimeError('Battery unknown or below 20%')
        if args.wake or args.exercise:
-            stats = before.get('stats')
-            if (not isinstance(stats, list) or not stats or
-                    not isinstance(stats[0], dict) or stats[0].get('activity_level') != 3):
+            if steamvr_activity(before.get('stats')) != 3:
                raise RuntimeError('Frame is awake or SteamVR activity is unknown; active session untouched')
        if args.wake or args.exercise:
            # Independent systemd timer restores power even if the controller is
@@ -36,16 +36,25 @@ def remote(command, stdin=None, timeout=15):


 PROBE = r'''
-import json, pathlib, subprocess
+import json, math, pathlib, subprocess
 power=[]
 for item in pathlib.Path('/sys/class/power_supply').glob('*/capacity'):
    try:
        if (item.parent/'type').read_text().strip() == 'Battery':
            power.append({'name':item.parent.name,'percent':int(item.read_text().strip())})
    except (OSError,ValueError): pass
+proximity=[]
+for item in pathlib.Path('/sys/bus/iio/devices').glob('iio:device*/in_proximity_raw'):
+    try:
+        value=float(item.read_text().strip())
+        if math.isfinite(value) and value >= 0: proximity.append(value)
+    except (OSError,ValueError): pass
 stats=subprocess.run(['/opt/steamvr/bin/linuxarm64/vrcmd','--stats'],capture_output=True,text=True,timeout=5)
-try: activity=json.loads(stats.stdout)[0]['activity_level'] if stats.returncode == 0 else None
-except (ValueError,KeyError,IndexError,TypeError): activity=None
+try:
+    rows=json.loads(stats.stdout) if stats.returncode == 0 else None
+    levels=[row.get('activity_level') for row in rows if isinstance(row,dict) and row.get('operation')=='status'] if isinstance(rows,list) else []
+    activity=levels[0] if len(levels)==1 and type(levels[0]) is int else None
+except (ValueError,TypeError): activity=None
 panels=subprocess.run(['/opt/steamvr/bin/linuxarm64/vrcmd','--overlays'],capture_output=True,text=True,timeout=5)
 panel=next((line.strip() for line in panels.stdout.splitlines() if 'valve.steam.desktopgame.2001947813' in line),None)
 base=pathlib.Path.home()/'.local/share/frame-control/decky/plugins'
@@ -59,7 +68,7 @@ if base.is_dir() and not base.is_symlink():
            if isinstance(p.get('storeId'),int): plugins.append({'id':p['storeId'],'name':manifest['name']})
        except (OSError,ValueError,KeyError): pass
 service=subprocess.run(['systemctl','--user','is-active','frame-control-headset.service'],capture_output=True,text=True)
-print(json.dumps({'battery':power,'activity':activity,'panel':panel,
+print(json.dumps({'battery':power,'proximity':proximity,'activity':activity,'panel':panel,
                  'panelService':service.returncode==0,'plugins':plugins}))
 '''

@@ -117,11 +126,15 @@ def main(worn_confirmed=False):
            raise RuntimeError('Battery capacity unavailable or below 20%; no device session started')
        if before['activity'] is None or before['activity'] >= 3:
            raise RuntimeError('SteamVR is in standby; no worn-headset check started')
+        if not before.get('proximity'):
+            raise RuntimeError('Proximity reading unavailable; no worn-headset check started')
        if not before['panelService'] or not before['plugins']:
            raise RuntimeError('Install and open the Frame Control panel and a Framey plugin before this check')
        after_lock = probe()
-        if after_lock['activity'] >= 3 or min(x['percent'] for x in after_lock['battery']) < 20:
-            raise RuntimeError('Activity or battery changed after acquiring the lock')
+        if (not isinstance(after_lock.get('activity'), int) or after_lock['activity'] >= 3 or
+                not after_lock.get('proximity') or not after_lock.get('battery') or
+                min(x['percent'] for x in after_lock['battery']) < 20):
+            raise RuntimeError('Activity, proximity or battery changed after acquiring the lock')
        state = json.dumps({'nonce':token,'started':time.time()})
        code = "import pathlib; p=pathlib.Path.home()/'.local/share/frame-control/headset/worn-check.json'; p.write_text(" + repr(state) + ")"
        remote('python3 -c ' + shlex.quote(code))
@@ -192,6 +192,13 @@ u=h/'.config/systemd/user/frame-control-decky.service'; u.parent.mkdir(parents=T
                    self.assertEqual(
                        ssh(f'sha256sum {installed}/dist/{chunk}').split()[0],
                        hashlib.sha256(expected_chunk).hexdigest())
+                if plugin['id'] == 53:
+                    self.assertEqual(ssh(f'test -f {installed}/py_modules/click.py && echo yes').strip(), 'yes')
+                    receipt = json.loads(ssh(f'cat {installed}/.frame-control-store.json'))
+                    self.assertEqual(receipt['compatShims'], ['shotty-click-app-dir'])
+                if plugin['id'] == 111:
+                    receipt = json.loads(ssh(f'cat {installed}/.frame-control-store.json'))
+                    self.assertEqual(receipt['compatShims'], ['music-control-bound-methods'])
                job = finished(ok('POST', '/api/decky/plugin',
                                  {'action':'remove','id':plugin['id'],'acknowledged':True}))
                self.assertFalse(job.get('error'), job)
@@ -1,14 +1,16 @@
 # Pinned Decky store test archives

 These are unmodified ZIPs downloaded from the official Decky store CDN on
-2026-10-25. Each ZIP includes its upstream `LICENSE`. They are test data, not
-plugins shipped or installed by Frame Control. The fake Frame tests serve them
+2026-10-25, except `111.zip` downloaded on 2026-10-26. Each ZIP includes its
+upstream `LICENSE`. They are test data, not plugins shipped or installed by
+Frame Control. The fake Frame tests serve them
 from a local fixture so CI does not depend on the store being online.

 | File | Official plugin | Version | Store SHA-256 |
 | --- | --- | --- | --- |
 | `7.zip` | CSS Loader | 2.1.3 | `99beaf1374af82408e6d056e0b0147e5fca544e1035fa7ab88419231697bc231` |
 | `12.zip` | MusicControl | 1.1.6 | `246b89fd653c60a735b1cc401d1b0937d5cb969eea9024561661ff741f081d62` |
+| `111.zip` | Music Control | 1.1.7 | `3f56a3f56034b277ea74a2c37cc84133b69e382aa6bcb0b43876776aac737ed9` |
 | `14.zip` | ProtonDB Badges | 1.3.4 | `90a3453ac02709cad64096e7539fd8141fa56f99ae3441fc24a4990dc9684358` |
 | `123.zip` | Steam Status | 1.2.3 | `9053308e04a74f44745b45b9f4f50af3673348d367e7b14bacc5677de707ac4e` |
 | `50.zip` | Storage Cleaner | 1.4.0 | `1afa1a6f129c5d419de0e0bf0f6db8d8e50385a5659179346e996031ea372591` |
@@ -20,6 +22,7 @@ from a local fixture so CI does not depend on the store being online.
 The matching source projects are
 [CSS Loader](https://github.com/suchmememanyskill/SDH-CssLoader),
 [MusicControl](https://github.com/nikurasu/MusicControl),
+[Music Control](https://github.com/martinpl/music-control),
 [ProtonDB Badges](https://github.com/bschelst/protondb-decky),
 [Steam Status](https://github.com/bschelst/steamstatus-decky),
 [Storage Cleaner](https://github.com/mcarlucci/decky-storage-cleaner),
@@ -5,6 +5,8 @@ from pathlib import Path
 ROOT = Path(__file__).parent / 'fixtures/framey-official'
 PLUGINS = (
    {'id': 12, 'name': 'MusicControl', 'version': '1.1.6', 'api_version': 'legacy', 'folder': 'MusicControl', 'sha256': '246b89fd653c60a735b1cc401d1b0937d5cb969eea9024561661ff741f081d62'},
+    {'id': 111, 'name': 'Music Control', 'version': '1.1.7', 'api_version': 'legacy',
+     'folder': 'MusicControl', 'sha256': '3f56a3f56034b277ea74a2c37cc84133b69e382aa6bcb0b43876776aac737ed9'},
    {'id': 14, 'name': 'ProtonDB Badges', 'version': '1.3.4', 'api_version': 2,
     'folder': 'protondb-decky', 'sha256': '90a3453ac02709cad64096e7539fd8141fa56f99ae3441fc24a4990dc9684358'},
    {'id': 123, 'name': 'Steam Status', 'version': '1.2.3', 'api_version': 2,
@@ -17,6 +19,10 @@ PLUGINS = (
     'folder': 'hltb-for-deck', 'sha256': 'bd54a23b0b8ec0798aa590e5be236522a593529d7680e77fb888e2971bf3d558'},
    {'id': 36, 'name': 'SteamGridDB', 'version': '1.8.1', 'api_version': 1,
     'folder': 'decky-steamgriddb', 'sha256': 'e84f5b1f111af8862b06218479491fbf61036e1bfd9f16f93f9901e9b9ebc5e0'},
+    {'id': 53, 'name': 'Shotty', 'version': '0.1.0', 'api_version': 'legacy',
+     'folder': 'Shotty', 'sha256': 'ab7f6618b264a0cb766525e788cef6c3e1478c0fef98a701225e5e8af441e2fe'},
+    {'id': 63, 'name': 'Free Loader', 'version': '1.6.0', 'api_version': 1,
+     'folder': 'free-loader', 'sha256': '05208aee6f6ba824391d8ddc81b1168b2599a9711e7528cdaa789f6cc710b42a'},
    {'id': 135, 'name': 'Deck Shelves', 'version': '2.0.0', 'api_version': 1,
     'folder': 'Deck-Shelves', 'sha256': 'b566280ad38fd3ecd584b5b46a855f301539eb9a86063834c64b7045f7063f91'},
 )
@@ -7,6 +7,7 @@ const testSource=source.replace(/\n  start\(\);\n\}\)\(\);\s*$/, '\n  window.__s
 assert.notEqual(testSource,source);
 const states=[];
 const React={Fragment:'fragment',Component:class {},createElement:(type,props,...children)=>({type,props:props||{},children}),
+  cloneElement:(element,props)=>({...element,props:{...element.props,...props}}),
  useState:value=>[value,next=>states.push(next)], useRef:value=>({current:value}),
  useEffect(){},isValidElement:value=>!!value?.type};
 class Element {constructor(){this.children=[];this.textContent='';this.attributes={};}
@@ -28,6 +29,10 @@ vm.runInContext(testSource,context);
 // No Steam React tree exists inside the isolated Framey iframe.
 assert.equal(window.DFL.getReactRoot({}),null);
 assert.equal(window.DFL.findInReactTree(window.DFL.getReactRoot(null),()=>true),null);
+const inertSteamComponent=window.DFL.fakeRenderComponent(undefined).type;
+assert.equal(inertSteamComponent.name,'MissingSteamComponent');
+assert.equal(window.DFL.fakeRenderComponent(undefined).type,inertSteamComponent);
+assert.equal(typeof window.DFL.afterPatch(inertSteamComponent.prototype,'render',()=>{}).unpatch,'function');
 // Official @decky/rollup bundles use the automatic JSX runtime, including keyed lists.
 const jsx=window.SP_JSX.jsx('p',{id:'message',children:'Saved'},'message-key');
 assert.equal(jsx.type,'p');
@@ -357,7 +362,86 @@ await assert.rejects(window.SteamClient.Storage.SetObject('undefined',undefined)
 assert.equal(window.indexedDB,undefined); // localForage must use bounded plugin storage.
 const unpatch=window.DFL.beforePatch({},'method',()=>{});
 assert.equal(unpatch.unpatch,unpatch);unpatch.unpatch();
-assert.equal(typeof window.DFL.showModal({type:'p'}).Close,'function');
+// Official AlarMe uses Focusable onActivate for pause, save and delete, without onClick.
+let activated=0, stopped=0;
+const activatable=window.DFL.Focusable({onActivate:()=>activated++});
+assert.equal(activatable.props.role,'button');assert.equal(activatable.props.tabIndex,0);
+activatable.props.onClick({stopPropagation:()=>stopped++});
+const ownTarget={};
+for(const key of ['Enter',' '])activatable.props.onKeyDown({key,target:ownTarget,currentTarget:ownTarget,
+  preventDefault(){},stopPropagation:()=>stopped++});
+activatable.props.onKeyDown({key:'Enter',target:{},currentTarget:ownTarget,preventDefault(){}});
+assert.equal(activated,3);assert.equal(stopped,3);
+const inertFocusable=window.DFL.Focusable({onActivate:()=>activated++,disabled:true});
+inertFocusable.props.onClick({});
+inertFocusable.props.onKeyDown({key:'Enter',target:ownTarget,currentTarget:ownTarget});
+assert.equal(activated,3);assert.equal(inertFocusable.props['aria-disabled'],true);
+let pointerCalls=0;
+window.DFL.Focusable({onClick:()=>pointerCalls++,onActivate:()=>activated++}).props.onClick({stopPropagation(){}});
+assert.equal(pointerCalls,1);assert.equal(activated,3);
+// Dialog actions must preserve descriptions, cancellation and the dialog they belong to.
+const modalRoot=roots.get(elements.get('framey-modal'));
+let confirmed=0, cancelled=0, dismissed=0;
+const modalHandle=window.DFL.showModal(React.createElement(window.DFL.ConfirmModal,{
+  strTitle:'Remove preset?',strDescription:'Only this private preset will be removed.',
+  strOKButtonText:'Remove',strCancelButtonText:'Keep',
+  onOK:()=>confirmed++,onCancel:()=>cancelled++,closeModal:()=>dismissed++}));
+let modal=modalRoot.value.at(-1).children.at(-1);
+let confirm=modal.type(modal.props);
+assert.equal(nodes(confirm,'div')[0].children[0],'Only this private preset will be removed.');
+assert.deepEqual(nodes(confirm,'button').map(button=>button.children[0]),['Remove','Keep']);
+nodes(confirm,'button')[1].props.onClick();
+await modalHandle.ClosedPromise;
+assert.equal(confirmed,0);assert.equal(cancelled,1);assert.equal(dismissed,1);
+assert.equal(modalRoot.value,null);
+modalHandle.Close();assert.equal(dismissed,1);
+// Opening a confirmation from another dialog preserves its state; stale Close handles
+// cannot dismiss the newer dialog. Programmatic Close does not call plugin callbacks.
+const parentModal=window.DFL.showModal(React.createElement('p',{closeModal:()=>dismissed++}));
+const childModal=window.DFL.showModal(React.createElement(window.DFL.ConfirmModal,{
+  strTitle:'Confirm',bOKDisabled:true,bCancelDisabled:true,bMiddleDisabled:true,
+  onOK:()=>confirmed++,onCancel:()=>cancelled++,onMiddleButton:()=>confirmed++}));
+assert.equal(modalRoot.value.length,2);assert.equal(modalRoot.value[0].props.hidden,true);
+modal=modalRoot.value.at(-1).children.at(-1);confirm=modal.type(modal.props);
+for(const button of nodes(confirm,'button')){assert.equal(button.props.disabled,true);button.props.onClick();}
+assert.equal(confirmed,0);assert.equal(cancelled,1);
+let prevented=0;
+listeners.find(listener=>listener.type==='keydown').handler({key:'Escape',preventDefault:()=>prevented++});
+assert.equal(prevented,1);assert.equal(modalRoot.value.length,2);
+parentModal.Close();parentModal.Close();await parentModal.ClosedPromise;
+assert.equal(modalRoot.value.length,1);assert.equal(dismissed,1);
+childModal.Close();await childModal.ClosedPromise;assert.equal(modalRoot.value,null);
+let replacement;
+const first=window.DFL.showModal(React.createElement(window.DFL.ConfirmModal,{
+  onOK:()=>{replacement=window.DFL.showModal(React.createElement('p',null,'Next dialog'));}}));
+modal=modalRoot.value.at(-1).children.at(-1);
+nodes(modal.type(modal.props),'button')[0].props.onClick();
+await first.ClosedPromise;assert.equal(modalRoot.value.length,1);
+replacement.Update(React.createElement('p',null,'Updated'));
+assert.equal(modalRoot.value[0].children.at(-1).children[0],'Updated');
+replacement.Close();await replacement.ClosedPromise;
+const alert=window.DFL.ConfirmModal({bAlertDialog:true,onCancel:()=>cancelled++});
+assert.equal(nodes(alert,'button').length,1);
+const escapeModal=window.DFL.showModal(React.createElement('p',{onCancel:()=>cancelled++}));
+listeners.find(listener=>listener.type==='keydown').handler({key:'Escape',preventDefault(){}});
+await escapeModal.ClosedPromise;assert.equal(cancelled,2);assert.equal(modalRoot.value,null);
+// Updated confirmations retain scoped dismissal and use the replacement's callback.
+for (const actionIndex of [0,1]) for (const withCallback of [false,true]) {
+  let oldCloses=0, updatedCloses=0, updatedActions=0;
+  const updated=window.DFL.showModal(React.createElement('p',{closeModal:()=>oldCloses++}));
+  updated.Update(React.createElement(window.DFL.ConfirmModal,{
+    strTitle:'Updated confirmation',onOK:()=>updatedActions++,onCancel:()=>updatedActions++,
+    ...(withCallback ? {closeModal:()=>updatedCloses++} : {})}));
+  const updatedElement=modalRoot.value.at(-1).children.at(-1);
+  nodes(updatedElement.type(updatedElement.props),'button')[actionIndex].props.onClick();
+  assert.equal(modalRoot.value,null,'Updated OK/Cancel must close its own dialog');
+  await updated.ClosedPromise;
+  assert.equal(updatedActions,1);assert.equal(updatedCloses,Number(withCallback));assert.equal(oldCloses,0);
+  updated.Close();updatedElement.props.closeModal();
+  updated.Update(React.createElement('p',null,'Already closed'));
+  assert.equal(updatedCloses,Number(withCallback));assert.equal(modalRoot.value,null);
+}
+
 let selectedMenuItem=0;
 window.DFL.MenuItem({onSelected:()=>selectedMenuItem++}).props.onClick({});
 window.DFL.MenuItem({disabled:true,onSelected:()=>selectedMenuItem++}).props.onClick({});
@@ -76,17 +76,22 @@ class DeckyServiceScript(unittest.TestCase):
        self.assertEqual((self.base / 'PluginLoader').read_bytes(), first)
        receipt = self.base / '.frame-control/receipt.json'
        self.assertEqual(json.loads(receipt.read_text())['version'], 'v3.3.0')
-        self.assertTrue((Path(self.tmp.name) / '.config/systemd/user/frame-control-decky.service').is_file())
+        service = Path(self.tmp.name) / '.config/systemd/user/frame-control-decky.service'
+        first_unit = service.read_text()
+        self.assertIn('Environment=PATH='+str(Path(self.tmp.name) / '.local/bin')+
+                      ':/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin\n', first_unit)

        second = arm_binary(b'B')
        result = self.apply('update', second, version='v3.3.1', fail=True)
        self.assertNotEqual(result.returncode, 0)
        self.assertEqual((self.base / 'PluginLoader').read_bytes(), first)
        self.assertEqual(json.loads(receipt.read_text())['version'], 'v3.3.0')
+        self.assertEqual(service.read_text(), first_unit)

        result = self.apply('update', second, version='v3.3.1')
        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertEqual((self.base / 'PluginLoader').read_bytes(), second)
+        self.assertIn('Environment=PATH=', service.read_text())
        result = self.apply('remove')
        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertFalse((self.base / 'PluginLoader').exists())
@@ -30,6 +30,21 @@ def archive(flags=(), extra=None):
    return data, hashlib.sha256(data).hexdigest()


+def duplicate_archive(second=b'#!/bin/sh\nexit 0\n', second_mode=0o100755):
+    stream = io.BytesIO()
+    with warnings.catch_warnings(), zipfile.ZipFile(stream, 'w') as bundle:
+        warnings.simplefilter('ignore', UserWarning)
+        bundle.writestr('Example/plugin.json', json.dumps({'name': 'Example', 'flags': []}))
+        bundle.writestr('Example/dist/index.js', 'export default {};' + ' ' * 1200)
+        for mode, payload in ((0o100644, b'#!/bin/sh\nexit 0\n'), (second_mode, second)):
+            info = zipfile.ZipInfo('Example/bin/helper')
+            info.create_system = 3
+            info.external_attr = mode << 16
+            bundle.writestr(info, payload)
+    data = stream.getvalue()
+    return data, hashlib.sha256(data).hexdigest()
+
+
 class ArchiveTests(unittest.TestCase):
    def test_catalog_selects_valid_visible_latest_versions(self):
        records = [{'id': 42, 'name': 'Example', 'author': 'Panel Author', 'visible': True, 'versions':
@@ -80,6 +95,14 @@ class ArchiveTests(unittest.TestCase):
        with self.assertRaisesRegex(ValueError, 'manifest'):
            frame_decky_store.archive_info(data, hashlib.sha256(data).hexdigest(), 'Example')

+    def test_only_identical_duplicate_payloads_with_execute_bit_difference_are_accepted(self):
+        data, digest = duplicate_archive()
+        self.assertEqual(frame_decky_store.archive_info(data, digest, 'Example'), 'Example')
+        for data, digest in (duplicate_archive(second=b'#!/bin/sh\nexit 1\n'),
+                             duplicate_archive(second_mode=0o100666)):
+            with self.subTest(digest=digest), self.assertRaisesRegex(ValueError, 'Unsafe'):
+                frame_decky_store.archive_info(data, digest, 'Example')
+

@unittest.skipIf(os.name == 'nt', 'remote plugin transaction runs on Linux')
 class StoreTransaction(unittest.TestCase):
@@ -98,14 +121,14 @@ class StoreTransaction(unittest.TestCase):
        self.folder = home / '.local/share/frame-control/decky/plugins/Example'
        self.folder.parent.mkdir(parents=True)

-    def apply(self, action, data=None, expected='-'):
+    def apply(self, action, data=None, expected='-', plugin_id=42, folder='Example', version='1.0'):
        token = secrets.token_hex(12)
        source = Path('/tmp/frame-control-decky-plugin-' + token)
        if data is not None:
            source.write_bytes(data)
        digest = hashlib.sha256(data or b'').hexdigest()
        try:
-            return subprocess.run([sys.executable, '-', action, token, '42', digest, 'Example', '1.0', expected],
+            return subprocess.run([sys.executable, '-', action, token, str(plugin_id), digest, folder, version, expected],
                                  input=frame_decky_store.APPLY, text=True, capture_output=True,
                                  env=self.env, timeout=15)
        finally:
@@ -138,6 +161,133 @@ class StoreTransaction(unittest.TestCase):
        self.assertNotEqual(result.returncode, 0)
        self.assertTrue(external.exists())

+    def test_exact_shotty_archive_gets_isolated_click_import(self):
+        from framey_official import PLUGINS, archive as official_archive
+        plugin = next(p for p in PLUGINS if p['id'] == 53)
+        data = official_archive(plugin)
+        self.assertEqual(hashlib.sha256(data).hexdigest(), plugin['sha256'])
+        shotty = self.folder.parent / plugin['folder']
+        args = {'plugin_id': plugin['id'], 'folder': plugin['folder'], 'version': plugin['version']}
+        result = self.apply('install', data, **args)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        receipt = json.loads((shotty / '.frame-control-store.json').read_text())
+        self.assertEqual(receipt['sha256'], plugin['sha256'])
+        self.assertEqual(receipt['compatShims'], ['shotty-click-app-dir'])
+        compat = shotty / 'py_modules/click.py'
+        self.assertTrue(compat.is_file())
+        source = '''import asyncio, importlib.util, logging, sys, types
+from pathlib import Path
+folder = Path(sys.argv[1])
+sys.path.insert(0, str(folder/'py_modules'))
+decky = types.ModuleType('decky_plugin')
+decky.logger = logging.getLogger('shotty-test')
+decky.DECKY_PLUGIN_DIR = str(folder)
+sys.modules['decky_plugin'] = decky
+spec = importlib.util.spec_from_file_location('shotty', folder/'main.py')
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+assert module.Plugin.__name__ == 'Plugin'
+from click import get_app_dir
+assert get_app_dir('Shotty') == str(Path.home()/'.config/Shotty')
+photo = Path.home()/'.local/share/Steam/userdata/100/760/remote/42/screenshots/test.jpg'
+photo.parent.mkdir(parents=True)
+photo.write_bytes(b'local screenshot fixture')
+plugin = module.Plugin()
+assert asyncio.run(plugin.aggregate_all([[42, 'Local Test Game']])) == 1
+copied = Path.home()/'Pictures/Screenshots/Local Test Game/test.jpg'
+assert copied.read_bytes() == b'local screenshot fixture'
+'''
+        imported = subprocess.run([sys.executable, '-c', source, str(shotty)],
+                                  capture_output=True, text=True,
+                                  env={**self.env, 'XDG_CONFIG_HOME': str(Path(self.tmp.name)/'.config')}, timeout=10)
+        self.assertEqual(imported.returncode, 0, imported.stderr)
+        result = self.apply('remove', expected=plugin['sha256'], **args)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertFalse(shotty.exists())
+        stream = io.BytesIO()
+        with zipfile.ZipFile(stream, 'w') as bundle:
+            bundle.writestr('Shotty/plugin.json', json.dumps({'name': 'Shotty', 'flags': []}))
+            bundle.writestr('Shotty/dist/index.js', 'export default {};' + ' ' * 1200)
+        other = stream.getvalue()
+        result = self.apply('install', other, **args)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertFalse((shotty / 'py_modules/click.py').exists())
+        self.assertNotIn('compatShims', json.loads((shotty / '.frame-control-store.json').read_text()))
+
+    def test_exact_music_control_backend_calls_work_after_managed_install(self):
+        from framey_official import PLUGINS, archive as official_archive
+        plugin = next(p for p in PLUGINS if p['id'] == 111)
+        data = official_archive(plugin)
+        self.assertEqual(hashlib.sha256(data).hexdigest(), plugin['sha256'])
+        folder = self.folder.parent / plugin['folder']
+        args = {'plugin_id': plugin['id'], 'folder': plugin['folder'], 'version': plugin['version']}
+        result = self.apply('install', data, **args)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        receipt = json.loads((folder / '.frame-control-store.json').read_text())
+        self.assertEqual(receipt['sha256'], plugin['sha256'])
+        self.assertEqual(receipt['compatShims'], ['music-control-bound-methods'])
+        with zipfile.ZipFile(io.BytesIO(data)) as bundle:
+            original = bundle.read('MusicControl/main.py').decode()
+        self.assertNotEqual((folder / 'main.py').read_text(), original)
+
+        dbus = Path(self.tmp.name) / 'dbus-send'
+        dbus.write_text('''#!/usr/bin/env python3
+import os, sys
+from pathlib import Path
+args = ' '.join(sys.argv[1:])
+with Path(os.environ['MPRIS_CALLS']).open('a') as log: log.write(args + '\\n')
+if 'ListNames' in args:
+    print('method return\\n array [\\n string "org.freedesktop.DBus"\\n string "org.mpris.MediaPlayer2.fixture"\\n ]')
+elif 'string:PlaybackStatus' in args:
+    print('method return\\n variant string "Paused"')
+else:
+    print('method return')
+''')
+        dbus.chmod(0o700)
+        calls = Path(self.tmp.name) / 'mpris-calls'
+        source = '''import asyncio, importlib.util, sys, types
+from pathlib import Path
+decky = types.ModuleType('decky_plugin')
+sys.modules['decky_plugin'] = decky
+spec = importlib.util.spec_from_file_location('music_control', Path(sys.argv[1])/'main.py')
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+plugin = module.Plugin()
+async def check():
+    assert await plugin.sp_list_media_players() == 'org.mpris.MediaPlayer2.fixture'
+    await plugin.sp_set_media_player('org.mpris.MediaPlayer2.fixture')
+    assert await plugin.sp_get_media_player() == 'org.mpris.MediaPlayer2.fixture'
+    await plugin.sp_play()
+    await plugin.sp_pause()
+    await plugin.sp_next()
+    await plugin.sp_previous()
+    await plugin.sp_set_volume(0.25)
+    assert await plugin.sp_track_status() == 'Paused'
+asyncio.run(check())
+'''
+        called = subprocess.run([sys.executable, '-c', source, str(folder)],
+                                capture_output=True, text=True,
+                                env={**self.env, 'MPRIS_CALLS': str(calls)}, timeout=10)
+        self.assertEqual(called.returncode, 0, called.stderr)
+        logged = calls.read_text()
+        self.assertIn('org.freedesktop.DBus.ListNames', logged)
+        self.assertIn('org.mpris.MediaPlayer2.Player.PlayPause', logged)
+        self.assertIn('org.mpris.MediaPlayer2.Player.Pause', logged)
+        self.assertIn('string:Volume variant:double:0.25', logged)
+        self.assertIn('org.mpris.MediaPlayer2.fixture', logged)
+        result = self.apply('remove', expected=plugin['sha256'], **args)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertFalse(folder.exists())
+
+        older = next(p for p in PLUGINS if p['id'] == 12)
+        old_data = official_archive(older)
+        old_args = {'plugin_id': older['id'], 'folder': older['folder'], 'version': older['version']}
+        result = self.apply('install', old_data, **old_args)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertNotIn('compatShims', json.loads((folder / '.frame-control-store.json').read_text()))
+        with zipfile.ZipFile(io.BytesIO(old_data)) as bundle:
+            self.assertEqual((folder / 'main.py').read_bytes(), bundle.read('MusicControl/main.py'))
+
    def test_installed_script_entrypoints_execute_without_zip_exec_bits(self):
        data, _ = archive(extra=('Example/scripts/start.py',
                                 b'#!/bin/sh\nprintf "Framey script: %s\\n" "$1"\n'))
@@ -152,6 +302,16 @@ class StoreTransaction(unittest.TestCase):
        self.assertFalse((self.folder / 'plugin.json').stat().st_mode & 0o111)
        self.assertFalse((self.folder / 'dist/index.js').stat().st_mode & 0o111)

+    def test_identical_duplicate_archive_installs_without_widening_permissions(self):
+        data, _ = duplicate_archive()
+        result = self.apply('install', data)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        helper = self.folder / 'bin/helper'
+        self.assertEqual(helper.read_bytes(), b'#!/bin/sh\nexit 0\n')
+        self.assertTrue(helper.stat().st_mode & 0o100)
+        self.assertFalse(helper.stat().st_mode & 0o6000)
+        self.assertEqual(self.apply('remove').returncode, 0)
+
    def test_declared_executable_is_owner_only_without_privilege_bits(self):
        info = zipfile.ZipInfo('Example/bin/entrypoint')
        info.create_system = 3
@@ -0,0 +1,51 @@
+"""The local frontend audit still renders receipt-bound Framey panels."""
+import sandbox  # noqa: F401
+import base64
+import hashlib
+import importlib.util
+import io
+from pathlib import Path
+import tempfile
+import unittest
+import zipfile
+
+
+MODULE = Path(__file__).resolve().parents[1]/'scripts/framey-audit-browser.py'
+spec = importlib.util.spec_from_file_location('framey_audit_browser', MODULE)
+audit = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(audit)
+
+
+class ReceiptBoundAudit(unittest.TestCase):
+    def test_digest_checked_archive_renders_without_installed_plugin(self):
+        bundle = b"import './chunks/frontend.js';"
+        stream = io.BytesIO()
+        with zipfile.ZipFile(stream, 'w') as archive:
+            archive.writestr('Example/dist/index.js', bundle)
+            archive.writestr('Example/dist/chunks/frontend.js', b'export const ready = true;')
+        data = stream.getvalue()
+        digest = hashlib.sha256(data).hexdigest()
+        record = {'id':42, 'folder':'Example', 'sha256':digest}
+        page = audit.render_panel(record, data)
+        self.assertIn(base64.b64encode(bundle), page)
+        self.assertIn(f'/framey/module/42/{digest}/index.js'.encode(), page)
+        self.assertIn(b'const report=(kind,message)', page)
+        with self.assertRaisesRegex(ValueError, 'hash mismatch'):
+            audit.render_panel({**record, 'sha256':'0'*64}, data)
+
+        with tempfile.TemporaryDirectory() as directory:
+            cache = Path(directory)
+            (cache/(digest+'.zip')).write_bytes(data)
+            records = {42:record}
+            route = f'/framey/module/42/{digest}/'
+            self.assertEqual(audit.read_module_asset(route+'index.js', records, cache), bundle)
+            self.assertEqual(audit.read_module_asset(route+'chunks/frontend.js', records, cache),
+                             b'export const ready = true;')
+            for bad in (f'/framey/module/42/{"0"*64}/index.js',
+                        route+'chunks/../frontend.js', route+'other.json',
+                        f'/framey/module/042/{digest}/index.js'):
+                with self.subTest(bad=bad), self.assertRaises((ValueError, KeyError)):
+                    audit.read_module_asset(bad, records, cache)
+            (cache/(digest+'.zip')).write_bytes(data+b'changed')
+            with self.assertRaisesRegex(ValueError, 'hash mismatch'):
+                audit.read_module_asset(route+'index.js', records, cache)
@@ -33,7 +33,8 @@ class OfficialBundles(unittest.TestCase):
            self.assertIn(b'deckyFrontendLib.definePlugin', frontend)
            bundle.extractall(root)
            folder = Path(root) / plugin['folder']
-            (folder / '.frame-control-store.json').write_text(json.dumps({'storeId': plugin['id']}))
+            (folder / '.frame-control-store.json').write_text(json.dumps({
+                'storeId': plugin['id'], 'sha256': plugin['sha256']}))
            with patch.object(framey_panel, 'PLUGINS', Path(root)):
                page = framey_panel.panel(plugin['id']).decode()
            encoded = re.search(r'<script id="framey-bundle" type="application/json">([^<]+)</script>', page)
@@ -71,16 +72,17 @@ class OfficialBundles(unittest.TestCase):
                        self.assertEqual(manifest.get('api_version', 'legacy'), plugin['api_version'])
                        z.extractall(plugins)
                    folder = plugins / plugin['folder']
-                    (folder / '.frame-control-store.json').write_text(json.dumps({'storeId': plugin['id']}))
+                    (folder / '.frame-control-store.json').write_text(json.dumps({
+                        'storeId': plugin['id'], 'sha256': plugin['sha256']}))
                    with patch.object(framey_panel, 'PLUGINS', plugins):
                        page = framey_panel.panel(plugin['id']).decode()
                    encoded = re.search(r'<script id="framey-bundle" type="application/json"[^>]*>([^<]+)</script>', page)
                    self.assertIsNotNone(encoded)
                    self.assertEqual(base64.b64decode(encoded.group(1)), (folder / 'dist/index.js').read_bytes())
                    if plugin['id'] == 135:
-                        self.assertIn('data-module="/framey/module/135/index.js"', page)
+                        self.assertIn(f'data-module="/framey/module/135/{plugin["sha256"]}/index.js"', page)
                        with patch.object(framey_panel, 'PLUGINS', plugins):
-                            self.assertEqual(framey_panel.local_module(135, 'chunks/pluginApi-B8sV7970.js'),
+                            self.assertEqual(framey_panel.local_module(135, plugin['sha256'], 'chunks/pluginApi-B8sV7970.js'),
                                             (folder/'dist/chunks/pluginApi-B8sV7970.js').read_bytes())


@@ -227,7 +227,7 @@ assert.throws(()=>eval(EXPRESSION),/library is unavailable/);
        self.plugins = Path(tmp.name)/'plugins'
        self.folder = self.plugins/'protondb-decky'
        (self.folder/'dist').mkdir(parents=True)
-        (self.folder/'.frame-control-store.json').write_text(json.dumps({'storeId':14,'version':'1.3.4'}))
+        (self.folder/'.frame-control-store.json').write_text(json.dumps({'storeId':14,'version':'1.3.4','sha256':RECEIPT}))
        (self.folder/'plugin.json').write_text(json.dumps({'name':'ProtonDB Badges','api_version':2,'flags':[]}))
        (self.folder/'dist/index.js').write_text("export default () => ({content: SP_REACT.createElement('p', null, 'OK')});")
        home = patch.object(framey_panel, 'PLUGINS', self.plugins)
@@ -260,18 +260,36 @@ assert.throws(()=>eval(EXPRESSION),/library is unavailable/);
        chunks.mkdir()
        (chunks/'view.js').write_text('export const title = "Settings";')
        page = framey_panel.panel(14).decode()
-        self.assertIn('data-module="/framey/module/14/index.js"', page)
-        self.assertEqual(framey_panel.local_module(14, 'chunks/view.js'),
+        self.assertIn(f'data-module="/framey/module/14/{RECEIPT}/index.js"', page)
+        self.assertEqual(framey_panel.local_module(14, RECEIPT, 'chunks/view.js'),
                         b'export const title = "Settings";')
        for name in ('../plugin.json', 'chunks/../../plugin.json',
                     'chunks/view.js.map', 'other.js', 'chunks/%2e%2e/view.js'):
            with self.subTest(name=name), self.assertRaises(FileNotFoundError):
-                framey_panel.local_module(14, name)
+                framey_panel.local_module(14, RECEIPT, name)
        (chunks/'linked.js').symlink_to(chunks/'view.js')
        with self.assertRaises(FileNotFoundError):
-            framey_panel.local_module(14, 'chunks/linked.js')
+            framey_panel.local_module(14, RECEIPT, 'chunks/linked.js')
        with self.assertRaises(FileNotFoundError):
-            framey_panel.local_module(15, 'chunks/view.js')
+            framey_panel.local_module(15, RECEIPT, 'chunks/view.js')
+
+    def test_chunked_panel_rejects_modules_from_a_replaced_store_receipt(self):
+        (self.folder/'dist/index.js').write_text("import './chunks/view.js'; export default () => ({});")
+        chunks = self.folder/'dist/chunks'
+        chunks.mkdir()
+        (chunks/'view.js').write_text('export const version = 1;')
+        old_url = f'/framey/module/14/{RECEIPT}/chunks/view.js'
+        self.assertIn(f'/framey/module/14/{RECEIPT}/index.js', framey_panel.panel(14).decode())
+        self.assertEqual(framey_panel.local_module(14, RECEIPT, 'chunks/view.js'), b'export const version = 1;')
+        (self.folder/'.frame-control-store.json').write_text(json.dumps({
+            'storeId':14,'version':'2.0','sha256':'b'*64}))
+        (chunks/'view.js').write_text('export const version = 2;')
+        with self.assertRaisesRegex(FileNotFoundError, 'changed'):
+            framey_panel.local_module(14, RECEIPT, 'chunks/view.js')
+        self.assertEqual(framey_panel.local_module(14, 'b'*64, 'chunks/view.js'), b'export const version = 2;')
+        self.assertNotIn(old_url, framey_panel.panel(14).decode())
+        with self.assertRaises(FileNotFoundError):
+            framey_panel.local_module(14, 'invalid', 'chunks/view.js')

    def test_legacy_keyword_rpc_is_scoped_and_validated(self):
        import shlex
@@ -365,12 +383,16 @@ assert.throws(()=>eval(EXPRESSION),/library is unavailable/);

        (self.folder/'dist/chunks').mkdir()
        (self.folder/'dist/chunks/view.js').write_text('export const value = 1;')
-        status, headers, body = get('/framey/module/14/chunks/view.js')
+        status, headers, body = get(f'/framey/module/14/{RECEIPT}/chunks/view.js')
        self.assertEqual(status, 200)
        self.assertEqual(headers['Access-Control-Allow-Origin'], 'null')
        self.assertEqual(body, b'export const value = 1;')
-        self.assertEqual(get('/framey/module/14/chunks/../plugin.json')[0], 404)
-        self.assertEqual(get('/framey/module/15/chunks/view.js')[0], 404)
+        self.assertEqual(get(f'/framey/module/14/{RECEIPT}/chunks/../plugin.json')[0], 404)
+        self.assertEqual(get(f'/framey/module/15/{RECEIPT}/chunks/view.js')[0], 404)
+        (self.folder/'.frame-control-store.json').write_text(json.dumps({
+            'storeId':14,'version':'2.0','sha256':'b'*64}))
+        self.assertEqual(get(f'/framey/module/14/{RECEIPT}/chunks/view.js')[0], 404)
+        self.assertEqual(get(f'/framey/module/14/{"b"*64}/chunks/view.js')[0], 200)


 if __name__ == '__main__':
@@ -15,6 +15,18 @@ spec.loader.exec_module(check)


 class Safety(unittest.TestCase):
+    def test_status_row_can_follow_metrics_and_ambiguous_status_fails_closed(self):
+        self.assertEqual(check.steamvr_activity([
+            {'operation':'performance','frame_presents':12},
+            {'operation':'status','activity_level':3}]), 3)
+        self.assertEqual(check.steamvr_activity([
+            {'operation':'performance','frame_presents':12},
+            {'operation':'status','activity_level':1}]), 1)
+        self.assertIsNone(check.steamvr_activity([
+            {'operation':'status','activity_level':3},
+            {'operation':'status','activity_level':1}]))
+        self.assertIsNone(check.steamvr_activity([{'activity_level':3}]))
+
    def test_overlay_wait_is_bounded_and_stops_when_visible(self):
        from unittest.mock import Mock
        remote = Mock()
@@ -61,7 +73,7 @@ class Safety(unittest.TestCase):
    def test_power_restore_after_partial_setter_failure(self):
        state = {'battery':[99], 'pause':'power.pauseCompositorOnStandby=true',
                 'timeout':'power.turnOffScreensTimeout=17.000000','dashboardVisible':False,
-                 'stats':[{'activity_level':3}], 'proximity':[6.25]}
+                 'stats':[{'operation':'status','activity_level':3}], 'proximity':[6.25]}
        with tempfile.TemporaryDirectory() as folder, patch.object(check, 'Remote') as factory:
            remote = factory.return_value
            remote.python.return_value = state
@@ -78,7 +90,9 @@ class Safety(unittest.TestCase):
            self.assertIn('rmdir /tmp/frame-test.lock', commands[-1])

    def test_awake_or_unknown_activity_refuses_wake_and_install(self):
-        for stats in ([{'activity_level':1}], [{'activity_level':2}], [], None):
+        for stats in ([{'operation':'status','activity_level':1}],
+                      [{'operation':'performance'}, {'operation':'status','activity_level':2}],
+                      [], None):
            state = {'battery':[99], 'pause':'power.pauseCompositorOnStandby=true',
                     'timeout':'power.turnOffScreensTimeout=17.000000',
                     'dashboardVisible':False, 'stats':stats, 'proximity':[0.0]}
@@ -3,7 +3,9 @@ import sandbox  # noqa: F401
 import contextlib
 import importlib.util
 import io
+import json
 from pathlib import Path
+from types import SimpleNamespace
 import unittest
 from unittest.mock import patch

@@ -30,7 +32,7 @@ class WornGate(unittest.TestCase):
        self.assertIn('trusted pointer events alone do not prove',out.getvalue())

    def test_standby_is_read_only_under_owned_lock_and_releases_it(self):
-        state = {'battery':[{'percent':99}], 'activity':3, 'panelService':True,
+        state = {'battery':[{'percent':99}], 'activity':3, 'proximity':[6.25], 'panelService':True,
                 'plugins':[{'id':14,'name':'ProtonDB Badges'}], 'panel':None}
        code, report, remote, probe = self.run_gate(state)
        self.assertEqual(code, 1)
@@ -41,7 +43,7 @@ class WornGate(unittest.TestCase):
        self.assertIn('rmdir /tmp/frame-test.lock', remote.call_args_list[1].args[0])

    def test_low_battery_releases_owned_lock(self):
-        state = {'battery':[{'percent':19}], 'activity':0, 'panelService':True,
+        state = {'battery':[{'percent':19}], 'activity':0, 'proximity':[6.25], 'panelService':True,
                 'plugins':[{'id':14,'name':'ProtonDB Badges'}], 'panel':None}
        code, report, remote, probe = self.run_gate(state)
        self.assertEqual(code, 1)
@@ -50,7 +52,7 @@ class WornGate(unittest.TestCase):
        self.assertEqual(remote.call_count, 2)

    def test_foreign_lock_prevents_all_sensor_reads_and_is_never_removed(self):
-        state = {'battery':[{'percent':99}], 'activity':0, 'panelService':True,
+        state = {'battery':[{'percent':99}], 'activity':0, 'proximity':[6.25], 'panelService':True,
                 'plugins':[{'id':14,'name':'ProtonDB Badges'}], 'panel':None}
        code, report, remote, probe = self.run_gate(state, RuntimeError('File exists'))
        self.assertEqual(code, 1)
@@ -61,3 +63,56 @@ class WornGate(unittest.TestCase):

    def test_screenshot_palette_counts_distinct_colors(self):
        self.assertEqual(worn.color_count('0 #ff00aa 1 #ff00aa 2 #00ff00'), 2)
+
+    def test_missing_proximity_stops_before_panel_or_input_and_releases_lock(self):
+        state = {'battery':[{'percent':99}], 'activity':0, 'proximity':[],
+                 'panelService':True, 'plugins':[{'id':14,'name':'ProtonDB Badges'}], 'panel':None}
+        code, report, remote, probe = self.run_gate(state)
+        self.assertEqual(code, 1)
+        self.assertIn('Proximity reading unavailable', report)
+        probe.assert_called_once()
+        self.assertEqual(remote.call_count, 2)
+        self.assertIn('rmdir /tmp/frame-test.lock', remote.call_args_list[-1].args[0])
+
+    def test_proximity_disappearing_on_second_read_stops_before_input(self):
+        first = {'battery':[{'percent':99}], 'activity':0, 'proximity':[200.0],
+                 'panelService':True, 'plugins':[{'id':14,'name':'ProtonDB Badges'}], 'panel':None}
+        second = {**first, 'proximity':[]}
+        out = io.StringIO()
+        with patch.object(worn, 'probe', side_effect=[first, second]) as probe, \
+                patch.object(worn, 'remote') as remote, contextlib.redirect_stdout(out):
+            code = worn.main(worn_confirmed=True)
+        self.assertEqual(code, 1)
+        self.assertIn('Activity, proximity or battery changed', out.getvalue())
+        self.assertEqual(probe.call_count, 2)
+        self.assertEqual(remote.call_count, 2)
+
+    def test_probe_reads_activity_from_status_after_metrics(self):
+        rows = [{'operation':'performance','frame_presents':12},
+                {'operation':'status','activity_level':1}]
+        def run(argv, **_):
+            if argv[-1] == '--stats':
+                return SimpleNamespace(returncode=0, stdout=json.dumps(rows))
+            return SimpleNamespace(returncode=1, stdout='')
+        for current, expected in (
+            (rows, 1),
+            ([{'operation':'performance','frame_presents':12}], None),
+            (rows + [{'operation':'status','activity_level':3}], None),
+        ):
+            with self.subTest(rows=current):
+                rows = current
+                out = io.StringIO()
+                with patch('subprocess.run', side_effect=run), contextlib.redirect_stdout(out):
+                    exec(worn.PROBE, {})
+                result = json.loads(out.getvalue())
+                self.assertEqual(result['activity'], expected)
+                self.assertIsInstance(result['proximity'], list)
+
+    def test_probe_discards_nonfinite_proximity(self):
+        def glob(_path, pattern):
+            return [SimpleNamespace(read_text=lambda: 'nan')] if pattern == 'iio:device*/in_proximity_raw' else []
+        with patch('pathlib.Path.glob', autospec=True, side_effect=glob), \
+                patch('subprocess.run', return_value=SimpleNamespace(returncode=1, stdout='')), \
+                contextlib.redirect_stdout(io.StringIO()) as out:
+            exec(worn.PROBE, {})
+        self.assertEqual(json.loads(out.getvalue())['proximity'], [])
@@ -123,6 +123,12 @@ try:
            next_binary.write_bytes(data)
            os.replace(next_binary, binary)
            binary.chmod(0o700)
+            # The Frame's user-installed tools (including its Tailscale CLI)
+            # live here, while the systemd user manager omits this directory.
+            # Keep standard system paths for plugins that invoke OS tools.
+            plugin_path = ':'.join((str(home / '.local/bin'), '/usr/local/sbin',
+                                    '/usr/local/bin', '/usr/sbin', '/usr/bin',
+                                    '/sbin', '/bin'))
            text = ('[Unit]\nDescription=Decky Loader (Frame Control experimental user install)\n'
              'After=default.target\n[Service]\nType=simple\nRestart=on-failure\n'
              'RestartSec=5\nExecStart='+str(binary)+'\n'
@@ -130,6 +136,7 @@ try:
              'Environment=PRIVILEGED_PATH='+str(base)+'\n'
              'Environment=CHOWN_PLUGIN_PATH=0\nEnvironment=LIVE_RELOAD=0\n'
              'Environment=USE_CEF_CLOSE_WORKAROUND=0\nEnvironment=KEEP_SYSTEMD_SERVICE=1\n'
+              'Environment=PATH='+plugin_path+'\n'
              '[Install]\nWantedBy=default.target\n')
            service.write_text(text)
            receipt.write_text(json.dumps({'managedBy':'Frame Control','version':version,'sha256':digest})+'\n')
@@ -86,7 +86,7 @@ def archive_info(data, expected_hash, expected_name):
        folder = manifests[0].split('/')[0]
        if not SAFE_FOLDER.fullmatch(folder):
            raise ValueError('Invalid plugin folder')
-        seen = set()
+        seen = {}
        for entry in files:
            name = entry.filename
            mode = entry.external_attr >> 16
@@ -95,11 +95,21 @@ def archive_info(data, expected_hash, expected_name):
            if entry.is_dir() and parts[-1] == '':
                parts = parts[:-1]
            if ('\\' in name or name.startswith('/') or
-                any(part in ('', '.', '..') for part in parts) or name in seen or
+                any(part in ('', '.', '..') for part in parts) or
                parts[0] != folder or entry.file_size > 30 * 1024 * 1024 or
                kind not in (0, 0o040000, 0o100000)):
                raise ValueError('Unsafe plugin archive member')
-            seen.add(name)
+            prior = seen.get(name)
+            if prior is not None:
+                # Some official ZIPs repeat unchanged files with execute-bit
+                # differences. Reject any content or other mode ambiguity.
+                old_mode = prior.external_attr >> 16
+                if (prior.file_size != entry.file_size or
+                    ((old_mode ^ mode) & ~0o111) or
+                    archive.read(prior) != archive.read(entry)):
+                    raise ValueError('Unsafe plugin archive member')
+            else:
+                seen[name] = entry
            if entry.is_dir():
                continue
            with archive.open(entry) as source:
@@ -164,17 +174,26 @@ try:
            files=z.infolist()
            if not files or len(files)>3000 or sum(f.file_size for f in files)>150*1024*1024:
                raise RuntimeError('Plugin archive too large')
-            seen=set()
+            seen={}
            for f in files:
                parts=f.filename.split('/')
                if f.is_dir() and parts[-1]=='': parts=parts[:-1]
                kind=f.external_attr>>16&0o170000
                if (not parts or parts[0]!=folder or f.filename.startswith('/') or
                    any(part in ('','.','..') for part in parts) or '\\' in f.filename or
-                    f.filename in seen or f.file_size>30*1024*1024 or
+                    f.file_size>30*1024*1024 or
                    kind not in (0,0o040000,0o100000)):
                    raise RuntimeError('Unsafe plugin archive')
-                seen.add(f.filename)
+                prior=seen.get(f.filename)
+                if prior is not None:
+                    # Match desktop validation before zipfile overwrites a
+                    # repeated member during extraction.
+                    old_mode=prior.external_attr>>16
+                    if (prior.file_size!=f.file_size or
+                        ((old_mode^ (f.external_attr>>16)) & ~0o111) or
+                        z.read(prior)!=z.read(f)):
+                        raise RuntimeError('Unsafe plugin archive')
+                else: seen[f.filename]=f
            stage.mkdir(mode=0o700)
            z.extractall(stage)
            # zipfile drops execute bits. Legacy plugins also publish shebang
@@ -189,6 +208,46 @@ try:
                    entry.chmod(entry.stat().st_mode|0o100)
            unpacked=stage/folder
            if not unpacked.is_dir(): raise RuntimeError('Missing plugin folder')
+            compat_shims=[]
+            # Shotty 0.1.0 imports click.get_app_dir but never calls it. Its
+            # official ZIP omits click and Decky's bundled Python lacks it.
+            # Supply the Linux function only inside this exact plugin's
+            # py_modules path; other plugins keep their original imports.
+            if int(plugin_id)==53 and digest=='ab7f6618b264a0cb766525e788cef6c3e1478c0fef98a701225e5e8af441e2fe' and folder=='Shotty':
+                compat=unpacked/'py_modules/click.py'
+                if compat.exists(): raise RuntimeError('Shotty compatibility module collides with archive')
+                compat.parent.mkdir(parents=True,exist_ok=True)
+                compat.write_text(
+                    '"""Frame Control Linux compatibility for Shotty 0.1.0."""\n'
+                    'import os\n'
+                    'def get_app_dir(app_name, roaming=True, force_posix=False):\n'
+                    '    if not isinstance(app_name, str) or not app_name:\n'
+                    '        raise ValueError("app_name must be a nonempty string")\n'
+                    '    base = os.environ.get("XDG_CONFIG_HOME")\n'
+                    '    if not base or not os.path.isabs(base):\n'
+                    '        base = os.path.join(os.path.expanduser("~"), ".config")\n'
+                    '    return os.path.join(base, app_name)\n',encoding='utf-8')
+                compat_shims.append('shotty-click-app-dir')
+            # Music Control 1.1.7 passes `self` to its own bound methods.
+            # Python has already bound that argument, so even read-only player
+            # discovery raises TypeError. Repair only the SHA-pinned official
+            # source, and fail the transaction if its expected calls change.
+            if int(plugin_id)==111 and digest=='3f56a3f56034b277ea74a2c37cc84133b69e382aa6bcb0b43876776aac737ed9' and folder=='MusicControl':
+                main=unpacked/'main.py'
+                source=main.read_text(encoding='utf-8')
+                fixes={
+                    'self._get_dbus_env(self)':('self._get_dbus_env()',10),
+                    'self._sp_player_dbus(self,':('self._sp_player_dbus(',7),
+                    'self._sp_dbus_set(self,':('self._sp_dbus_set(',1),
+                    'self.sp_get_volume(self)':('self.sp_get_volume()',2),
+                    'self.sp_set_volume(self,':('self.sp_set_volume(',2),
+                }
+                for old,(new,count) in fixes.items():
+                    if source.count(old)!=count:
+                        raise RuntimeError('Music Control compatibility source changed')
+                    source=source.replace(old,new)
+                main.write_text(source,encoding='utf-8')
+                compat_shims.append('music-control-bound-methods')
            # Recheck under the transaction lock. Another store operation may
            # have installed a colliding name while this archive downloaded.
            proposed_name=json.loads((unpacked/'plugin.json').read_text()).get('name')
@@ -202,7 +261,9 @@ try:
                    if isinstance(peer_data,dict) and peer_data.get('name')==proposed_name:
                        raise RuntimeError('A different plugin with this name is already installed')
                except (OSError,ValueError,UnicodeError): continue
-            (unpacked/marker).write_text(json.dumps({'storeId':int(plugin_id),'sha256':digest,'version':version})+'\n')
+            record={'storeId':int(plugin_id),'sha256':digest,'version':version}
+            if compat_shims: record['compatShims']=compat_shims
+            (unpacked/marker).write_text(json.dumps(record)+'\n')
    # Stop even a failed unit before removal to cancel any pending auto-restart.
    if running or action=='remove': service('stop','frame-control-decky.service')
    try:
@@ -1790,7 +1790,7 @@
      },
      "backend": "Python + native payload",
      "hardware": "No specific hardware requirement detected statically; runtime requirements unverified.",
-      "nativePort": "The bin/hash helper needs an ARM64 build and cross-platform hashing tests; no ARM64 artifact is published.",
+      "nativePort": "A source-matched ARM64 bin/hash helper matched the official x86_64 helper on one synthetic ROM on the real Frame (docs/evidence/framey-emuchievements-arm-2026-10-26.md). The official ZIP still bundles x86_64 bytes and remains blocked; format coverage, packaging, plugin backend/UI, login and worn VR are unverified.",
      "uiSurfaces": [
        "local/Steam routes",
        "toasts",
@@ -3185,12 +3185,13 @@
        "https://github.com/tailscale-dev/deck-tailscale"
      ],
      "status": "partial",
-      "reason": "Settings render locally after the SuspensefulImage fallback. Tailscale daemon/state, connection and exit-node changes unverified; bundled localhost QR asset remains unavailable. No network settings were changed.",
+      "reason": "Settings render locally after the SuspensefulImage fallback. On the real Frame, exact official read-only backend status calls returned live state, exit-node and device entries when ~/.local/bin was in PATH; a transient user unit found the CLI with the proposed managed-service PATH. Live Framey Decky RPC, connection/exit-node changes and worn VR remain unverified; the bundled localhost QR asset is unavailable. No network settings were changed.",
      "blockInstall": false,
      "verification": [
        "static archive",
        "local browser",
-        "fake-Frame"
+        "fake-Frame",
+        "real Frame read-only backend"
      ],
      "browser": {
        "id": 43,
@@ -3794,8 +3795,8 @@
        "https://github.com/SteamDeckHomebrew/decky-loader",
        "https://github.com/yt-dlp/yt-dlp"
      ],
-      "status": "broken",
-      "reason": "Frontend audit failed: Cannot read properties of null (reading 'type').",
+      "status": "partial",
+      "reason": "An inert local component lets the exact frontend initialize and render its Settings view in opaque Chromium. Backend get_setting and plugin network were denied in the audit; Steam game-page theme injection has no verified target in Framey. Music search, playback, downloads, settings persistence and worn VR remain unverified.",
      "blockInstall": false,
      "verification": [
        "static archive",
@@ -3828,6 +3829,13 @@
        "sha256": "9ce293ab4db212c03c6b96dfbc5e4d92e874d33387463f53223773921f75a80e",
        "archiveValidation": "accepted",
        "result": "installed-removed"
+      },
+      "renderFollowUp": {
+        "evidence": "docs/evidence/framey-game-theme-music-2026-10-26.md",
+        "mode": "exact archive in opaque local Chromium; backend and network denied",
+        "frontendReady": true,
+        "settingsRendered": true,
+        "steamGamePagePatched": false
      }
    },
    {
@@ -3874,14 +3882,15 @@
      "sourceURLs": [
        "https://github.com/safijari/Shotty"
      ],
-      "status": "broken",
-      "reason": "Library snapshot fixes the frontend allApps crash. Actual published Decky 3.3.0 amd64 backend fails importing click.get_app_dir (ModuleNotFoundError); the archive does not bundle click. Screenshot aggregation/rescue was not run.",
+      "status": "partial",
+      "reason": "The frontend starts with the read-only Frame library snapshot. Frame Control adds a digest-scoped click.get_app_dir compatibility module to the managed install; the exact backend then imports and copies a synthetic Steam screenshot into a temporary Pictures folder in isolated Python. Actual Decky 3.3.0 ARM64 loading, live screenshots/rescue, in-VR panel and physical controller use remain unverified.",
      "blockInstall": false,
      "verification": [
        "static archive",
        "local browser",
        "fake-Frame",
-        "real Frame SSH"
+        "real Frame SSH",
+        "isolated Python backend"
      ],
      "browser": {
        "id": 53,
@@ -3912,6 +3921,13 @@
        "evidence": "docs/evidence/framey-library-context-2026-10-26.json",
        "mode": "real Frame read-only CEF projection; local Chromium snapshot replay; scoped actual amd64 backends",
        "frontendReady": true
+      },
+      "backendFollowUp": {
+        "evidence": "docs/evidence/framey-shotty-python-2026-10-26.md",
+        "mode": "exact archive managed transaction and isolated Python import/copy with temporary HOME",
+        "compatShim": "shotty-click-app-dir",
+        "syntheticScreenshotCopied": true,
+        "actualDeckyArm64": false
      }
    },
    {
@@ -4650,13 +4666,15 @@
        "https://github.com/jwhitlow45/free-loader",
        "https://github.com/jwhitlow45/free-loader.git"
      ],
-      "status": "broken",
-      "reason": "Unsafe plugin archive member.",
-      "blockInstall": true,
+      "status": "partial",
+      "reason": "The exact archive's duplicate names contain identical bytes and differ only in execute bits; the guarded installer now accepts them, and a private local install/remove transaction passed. The current opaque Chromium host renders Free Games but cannot load deals with backend/network denied. Exact official Python settings and empty local-deals methods passed in a no-network container with a Decky stub. Real Decky, feed refresh, notifications and worn VR remain unverified.",
+      "blockInstall": false,
      "verification": [
        "static archive",
        "local browser",
-        "fake-Frame"
+        "fake-Frame pinned install/remove",
+        "local exact-archive transaction",
+        "isolated Python backend"
      ],
      "browser": {
        "id": 63,
@@ -4673,8 +4691,8 @@
      },
      "archiveValidation": {
        "id": 63,
-        "accepted": false,
-        "reason": "Unsafe plugin archive member"
+        "accepted": true,
+        "folder": "free-loader"
      },
      "backend": "Python",
      "hardware": "No specific hardware requirement detected statically; runtime requirements unverified.",
@@ -4685,9 +4703,15 @@
      "fakeFrame": {
        "id": 63,
        "sha256": "05208aee6f6ba824391d8ddc81b1168b2599a9711e7528cdaa789f6cc710b42a",
-        "archiveValidation": "Unsafe plugin archive member",
-        "result": "blocked",
-        "reason": "ValueError: Unsafe plugin archive member."
+        "archiveValidation": "accepted",
+        "result": "installed-removed",
+        "reason": "Targeted pinned official fake-Frame install/remove passed after the validator change; the earlier full 116-plugin audit blocked this digest."
+      },
+      "localFollowUp": {
+        "evidence": "docs/evidence/framey-free-loader-duplicates-2026-10-26.md",
+        "hostCommit": "d963305",
+        "frontendReady": true,
+        "backendScope": "isolated official Python settings/defaults and empty local-deals read with a Decky stub"
      }
    },
    {
@@ -9558,12 +9582,13 @@
        "https://github.com/martinpl/music-control"
      ],
      "status": "partial",
-      "reason": "Panel initializer succeeds with backend/network blocked; actual controls and backend remain unverified.",
+      "reason": "Exact official backend bound-method calls are repaired in managed installs. An isolated fake dbus-send target accepted player discovery, transport and volume commands after the patch; real MPRIS players, actual Decky ARM64, album art and worn VR remain unverified.",
      "blockInstall": false,
      "verification": [
        "static archive",
        "local browser",
-        "fake-Frame"
+        "fake-Frame",
+        "isolated Python backend"
      ],
      "browser": {
        "id": 111,
@@ -9599,7 +9624,9 @@
        "sha256": "3f56a3f56034b277ea74a2c37cc84133b69e382aa6bcb0b43876776aac737ed9",
        "archiveValidation": "accepted",
        "result": "installed-removed"
-      }
+      },
+      "compatShim": "music-control-bound-methods",
+      "evidence": "docs/evidence/framey-music-control-bound-methods-2026-10-26.md"
    },
    {
      "id": 112,
@@ -10876,12 +10903,13 @@
        "https://github.com/mpcallahan/DeckyHourNotifications"
      ],
      "status": "partial",
-      "reason": "Initializer succeeds; timers, reminders, suspend inhibition and audio are unverified.",
+      "reason": "Silent labeled timer create/ticks/pause/cancel, preset save/cancel-confirm/delete and stopwatch start/lap/pause/reset/reopen pass in local Chromium with the official Decky 3.3.0 ARM64 backend. Audio, alarms/reminders, suspend inhibition, Steam overlays and worn VR remain unverified; notifications require the panel to stay open.",
      "blockInstall": false,
      "verification": [
        "static archive",
        "local browser",
-        "fake-Frame"
+        "fake-Frame",
+        "real Frame SSH"
      ],
      "browser": {
        "id": 124,
@@ -10941,7 +10969,7 @@
        "folder": "alarme-decky-plugin"
      },
      "backend": "Python",
-      "hardware": "No specific hardware requirement detected statically; runtime requirements unverified.",
+      "hardware": "Timers/stopwatch use Python. Optional sleep inhibition opens /dev/uinput; sound and auto-suspend are unverified. Steam game overlays have no target in the isolated panel.",
      "uiSurfaces": [
        "local/Steam routes",
        "toasts",
@@ -10958,6 +10986,12 @@
        "evidence": "docs/evidence/framey-running-context-2026-10-26.json",
        "mode": "synthetic nonempty running/library replay; backend and network denied",
        "frontendReady": true
+      },
+      "controlsFollowUp": {
+        "evidence": "docs/evidence/framey-dialog-controls-2026-10-26.json",
+        "mode": "local opaque-iframe Chromium with receipt-bound official ARM64 backend RPC/events; private silent data only",
+        "frontendReady": true,
+        "status": "partial"
      }
    },
    {
@@ -12045,12 +12079,13 @@
        "https://github.com/sponsors/santojon"
      ],
      "status": "partial",
-      "reason": "The exact chunked frontend now initializes and renders Deck Shelves settings in an opaque local Chromium panel. Backend calls were denied; Home-screen shelf injection has no verified Steam UI target in Framey. Settings writes, real backend behavior and worn VR are unverified.",
+      "reason": "The exact chunked frontend renders settings in opaque local Chromium. The official Python backend saved a shelf and returned it after reopen with a stub Decky module and temporary settings directory. Actual Decky RPC, real Frame settings, Steam Home shelf injection and worn VR remain unverified.",
      "blockInstall": false,
      "verification": [
        "static archive",
        "local browser",
-        "fake-Frame"
+        "fake-Frame",
+        "isolated Python backend"
      ],
      "browser": {
        "id": 135,
@@ -12085,6 +12120,13 @@
        "mode": "exact archive in opaque local Chromium; backend and network denied",
        "frontendReady": true,
        "settingsRendered": true
+      },
+      "backendFollowUp": {
+        "evidence": "docs/evidence/framey-deck-shelves-browser-2026-10-26.md",
+        "mode": "exact archive Python with stub Decky module and temporary settings directory",
+        "defaultSettingsRead": true,
+        "shelfSaveReopen": true,
+        "actualDeckyRpc": false
      }
    },
    {
@@ -197,6 +197,26 @@
  }, {passive:true});

  const passthrough = tag => ({children, ...props}) => R.createElement(tag, props, children);
+  const Focusable = ({children, onActivate, onClick, onKeyDown, disabled, tabIndex, role, ...props}) => {
+    const actionable=typeof onActivate==='function' || typeof onClick==='function';
+    const activate = event => {
+      if (disabled || event.defaultPrevented) return;
+      event.stopPropagation();
+      (onClick || onActivate)?.(event);
+    };
+    return R.createElement('div', {...props, role:role || (actionable ? 'button' : undefined),
+      tabIndex:tabIndex ?? (actionable ? (disabled ? -1 : 0) : undefined),
+      'aria-disabled':actionable && disabled ? true : undefined,
+      onClick:actionable ? activate : undefined, onKeyDown:event=>{
+        onKeyDown?.(event);
+        if (actionable && !disabled && !event.defaultPrevented && event.target===event.currentTarget &&
+            (event.key==='Enter' || event.key===' ')) {
+          event.preventDefault();
+          event.stopPropagation();
+          (onActivate || onClick)?.(event);
+        }
+      }}, children);
+  };
  const Field = ({label, description, children}) => R.createElement('label', null,
    R.createElement('strong', null, label), description && R.createElement('small', null, description), children);
  const ToggleField = ({label, description, checked, disabled, onChange}) => R.createElement(Field, {label, description},
@@ -263,11 +283,61 @@
  const MenuItem = ({children, disabled, bDisabled, onClick, onSelected}) =>
    R.createElement('button', {type:'button',disabled:!!(disabled || bDisabled),
      onClick:event=>{if(!disabled && !bDisabled)(onClick || onSelected)?.(event);}}, children);
-  const ConfirmModal = ({strTitle, strOKButtonText, onOK, children}) => R.createElement('section', null,
-    R.createElement('h2', null, strTitle), children,
-    R.createElement('button', {type:'button', onClick:()=>{onOK?.(); closeModal();}}, strOKButtonText || 'Close'));
+  const ConfirmModal = ({strTitle, strDescription, strOKButtonText, strCancelButtonText,
+    strMiddleButtonText, onOK, onCancel, onMiddleButton, closeModal,
+    bOKDisabled, bCancelDisabled, bMiddleDisabled, bAlertDialog, children}) => {
+    const action = (callback, disabled) => () => {
+      if (disabled) return;
+      callback?.();
+      closeModal?.();
+    };
+    return R.createElement('section', null,
+      R.createElement('h2', null, strTitle),
+      strDescription && R.createElement('div', null, strDescription), children,
+      R.createElement('button', {type:'button', disabled:!!bOKDisabled,
+        onClick:action(onOK, bOKDisabled)}, strOKButtonText || 'OK'),
+      onMiddleButton && R.createElement('button', {type:'button', disabled:!!bMiddleDisabled,
+        onClick:action(onMiddleButton, bMiddleDisabled)}, strMiddleButtonText || 'More'),
+      !bAlertDialog && R.createElement('button', {type:'button', disabled:!!bCancelDisabled,
+        onClick:action(onCancel, bCancelDisabled)}, strCancelButtonText || 'Cancel'));
+  };
  const modalRoot = window.ReactDOM.createRoot(document.getElementById('framey-modal'));
-  const closeModal = () => modalRoot.render(null);
+  const modals = [];
+  let modalId = 0;
+  const renderModals = () => {
+    document.getElementById('framey-root').inert = modals.length > 0;
+    modalRoot.render(modals.length ? modals.map((modal,index) =>
+    R.createElement('section', {key:modal.id, className:'framey-dialog', tabIndex:-1,
+      ref:node=>{modal.node=node;}, hidden:index!==modals.length-1,
+      role:'dialog', 'aria-modal':index===modals.length-1 ? true : undefined,
+      'aria-label':typeof modal.element?.props?.strTitle==='string' ? modal.element.props.strTitle : 'Plugin dialog'},
+      !modal.element?.props?.bHideCloseIcon && R.createElement('button', {
+        type:'button', disabled:!!modal.element?.props?.bCancelDisabled,
+        onClick:()=>dismissModal(modal)}, 'Close'), modal.element)) : null);
+  };
+  function dismissModal(modal) {
+    if (modal.element?.props?.bCancelDisabled) return;
+    modal.element?.props?.onCancel?.();
+    modal.dismiss();
+  }
+  addEventListener('keydown', event => {
+    const modal=modals.at(-1);
+    if (!modal) return;
+    if (event.key === 'Tab') {
+      const controls = [...(modal.node?.querySelectorAll('button,input,select,textarea,a[href],[tabindex]') || [])]
+        .filter(node=>!node.disabled && node.tabIndex>=0 && node.getClientRects().length);
+      const index=controls.indexOf(document.activeElement);
+      if (index < 0 || (!event.shiftKey && index===controls.length-1) || (event.shiftKey && index===0)) {
+        event.preventDefault();
+        (event.shiftKey ? controls.at(-1) : controls[0])?.focus();
+      }
+      return;
+    }
+    if (event.key !== 'Escape') return;
+    event.preventDefault();
+    if (modal.element?.props?.onEscKeypress) modal.element.props.onEscKeypress();
+    else dismissModal(modal);
+  });
  const localPath = path => typeof path === 'string' && path.length <= 120 &&
    /^\/[A-Za-z0-9/_-]+$/.test(path) && !path.includes('//');
  const routePattern = path => typeof path === 'string' && path.length <= 120 &&
@@ -320,10 +390,40 @@
    addPatch:()=>()=>{}, removePatch:()=>{}, addGlobalComponent:()=>{}, removeGlobalComponent:()=>{},
  };
  const noPatch = () => {const undo=()=>{};undo.unpatch=undo;return undo;};
+  class MissingSteamComponent {}
  const showModal = element => {
-    modalRoot.render(R.createElement('section', null,
-      R.createElement('button', {type:'button',onClick:closeModal}, 'Close'), element));
-    return {Close:closeModal};
+    let resolveClosed;
+    const ClosedPromise = new Promise(resolve=>{resolveClosed=resolve;});
+    const modal = {id:++modalId, previousFocus:document.activeElement, source:element};
+    const Close = () => {
+      const index=modals.indexOf(modal);
+      if (index < 0) return;
+      const wasTop=index===modals.length-1;
+      modals.splice(index,1);
+      renderModals();
+      resolveClosed();
+      if (wasTop) setTimeout(()=>{
+        if (modals.length) modals.at(-1).node?.focus();
+        else if (modal.previousFocus?.isConnected) modal.previousFocus.focus();
+      },0);
+    };
+    modal.dismiss = () => {
+      if (!modals.includes(modal)) return;
+      const callback=modal.source?.props?.closeModal;
+      if (callback !== modal.dismiss) callback?.();
+      Close();
+    };
+    modal.element = R.isValidElement(element) ? R.cloneElement(element, {closeModal:modal.dismiss}) : element;
+    modals.push(modal);
+    renderModals();
+    setTimeout(()=>{if(modals.at(-1)===modal) modal.node?.focus();},0);
+    return {Close, ClosedPromise, Update:next=>{
+      if (!modals.includes(modal)) return;
+      // Keep replacement dialogs dismissible inside this isolated host too.
+      modal.source=next;
+      modal.element=R.isValidElement(next) ? R.cloneElement(next, {closeModal:modal.dismiss}) : next;
+      renderModals();
+    }};
  };
  // These are Framey's own styles and components, never Steam's webpack cache.
  // Keep the registry finite: an unknown Steam implementation stays unavailable.
@@ -373,7 +473,7 @@
    definePlugin: init => init,
    PanelSection, PanelSectionRow: passthrough('div'), Field, ToggleField, DropdownItem,
    Dropdown: DropdownItem, ButtonItem, DialogCheckbox, TextField, SliderField,
-    Focusable: passthrough('div'), ScrollPanel: passthrough('div'), ScrollPanelGroup: passthrough('div'),
+    Focusable, ScrollPanel: passthrough('div'), ScrollPanelGroup: passthrough('div'),
    DialogButton: passthrough('button'), DialogButtonPrimary: passthrough('button'), ConfirmModal,
    DialogButtonSecondary: passthrough('button'), Button: ButtonItem, GamepadButton: passthrough('button'),
    Toggle: ToggleField, Spinner, SteamSpinner:Spinner, Tabs, SidebarNavigation,
@@ -410,7 +510,11 @@
      for(const classes of classModules.values())
        for(const name of Object.keys(classes)) if(classes[name]===token)return name;
    },
-    findSP:()=>null, fakeRenderComponent:()=>null,
+    findSP:()=>null,
+    // Some legacy panels dereference the type of a Steam-only component before
+    // installing a patch. Give them an inert local type; no Steam tree is
+    // rendered or patched in this isolated iframe.
+    fakeRenderComponent:()=>({type:MissingSteamComponent}),
    appDetailsClasses: {}, appDetailsHeaderClasses: {},
    useParams: () => currentParams,
  };
@@ -20,7 +20,17 @@ class PanelError(ValueError):
    pass


-def _owned_dist(plugin_id):
+def _receipt_digest(path):
+    if path.is_symlink() or not path.is_file() or path.stat().st_size > 16_384:
+        raise FileNotFoundError('Framey plugin store receipt unavailable')
+    meta = json.loads(path.read_text())
+    digest = meta.get('sha256') if isinstance(meta, dict) else None
+    if not isinstance(digest, str) or not RECEIPT.fullmatch(digest):
+        raise FileNotFoundError('Framey plugin store receipt unavailable')
+    return meta, digest
+
+
+def _owned_dist(plugin_id, expected_receipt=None):
    """Locate a compatible store-owned frontend without following linked paths."""
    if type(plugin_id) is not int or plugin_id <= 0 or not PLUGINS.is_dir() or PLUGINS.is_symlink():
        raise FileNotFoundError('Framey plugin unavailable')
@@ -31,16 +41,17 @@ def _owned_dist(plugin_id):
        manifest = folder/'plugin.json'
        dist = folder/'dist'
        entry = dist/'index.js'
-        if any(p.is_symlink() for p in (receipt, manifest, dist, entry)):
+        if any(p.is_symlink() for p in (manifest, dist, entry)):
            continue
        try:
-            if not receipt.is_file() or receipt.stat().st_size > 16_384:
-                continue
-            meta = json.loads(receipt.read_text())
-            if not isinstance(meta, dict):
-                continue
-            if meta.get('storeId') != plugin_id:
-                continue
+            meta, digest = _receipt_digest(receipt)
+        except (OSError, ValueError, UnicodeError):
+            continue
+        if meta.get('storeId') != plugin_id:
+            continue
+        try:
+            if expected_receipt is not None and digest != expected_receipt:
+                raise FileNotFoundError('Framey plugin changed; reopen its panel')
            if not manifest.is_file() or manifest.stat().st_size > 16_384:
                raise FileNotFoundError('Framey plugin manifest unavailable')
            data = json.loads(manifest.read_text())
@@ -76,7 +87,11 @@ def _owned_dist(plugin_id):
                            supported = True
                if not supported:
                    raise FileNotFoundError('This API v1 frontend does not use the supported Decky API bridge')
-            return dist, bundle
+            if _receipt_digest(receipt) != (meta, digest):
+                raise FileNotFoundError('Framey plugin changed; reopen its panel')
+            return dist, bundle, digest
+        except FileNotFoundError:
+            raise
        except (OSError, ValueError):
            raise FileNotFoundError('Framey plugin files are invalid')
    raise FileNotFoundError('Plugin is not managed by the Frame Control Decky store')
@@ -87,11 +102,13 @@ def local_bundle(plugin_id):
    return _owned_dist(plugin_id)[1]


-def local_module(plugin_id, name):
+def local_module(plugin_id, receipt, name):
    """Serve only JavaScript within a store-owned dist directory for module imports."""
    if not isinstance(name, str) or not MODULE_PATH.fullmatch(name):
        raise FileNotFoundError('Framey module path unavailable')
-    dist, bundle = _owned_dist(plugin_id)
+    if not isinstance(receipt, str) or not RECEIPT.fullmatch(receipt):
+        raise FileNotFoundError('Framey module receipt unavailable')
+    dist, bundle, _ = _owned_dist(plugin_id, receipt)
    if name == 'index.js':
        return bundle
    target = dist
@@ -101,14 +118,17 @@ def local_module(plugin_id, name):
            raise FileNotFoundError('Framey module path unavailable')
    if not target.is_file() or target.stat().st_size > 8*1024*1024:
        raise FileNotFoundError('Framey module unavailable')
-    return target.read_bytes()
+    data = target.read_bytes()
+    if _receipt_digest(dist.parent/'.frame-control-store.json')[1] != receipt:
+        raise FileNotFoundError('Framey plugin changed; reopen its panel')
+    return data


 def panel(plugin_id):
    """The plugin receives no Frame UI key and is sandboxed to an opaque origin."""
-    bundle = local_bundle(plugin_id)
+    _, bundle, receipt = _owned_dist(plugin_id)
    encoded = base64.b64encode(bundle).decode('ascii')
-    module = f' data-module="/framey/module/{plugin_id}/index.js"' if b'./chunks/' in bundle else ''
+    module = f' data-module="/framey/module/{plugin_id}/{receipt}/index.js"' if b'./chunks/' in bundle else ''
    return ('''<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
 <title>Framey plugin</title><style>body{font:21px/1.4 system-ui;background:#0d1925;color:#f3f7fa;margin:0;padding:20px}
 button,select,input{font:inherit;min-height:52px;background:#23618c;color:#fff;border:1px solid #72baf0;border-radius:9px;padding:8px}
@@ -119,7 +139,9 @@ label{display:grid;gap:6px;margin:10px 0}small{color:#b9c9d6}
 .framey-sections,.framey-library{display:flex;flex-direction:column;gap:12px}.framey-actions{display:flex;flex-wrap:wrap;gap:8px}
 .framey-action{min-height:52px}.framey-button-child{display:inline-flex;align-items:center;gap:8px}.framey-green{background:#246b42}
 .framey-long-title{overflow-wrap:anywhere}.framey-muted{background:#1b3042}.framey-image{max-width:100%;object-fit:contain}
-.framey-focus:focus-visible{outline:4px solid #f8d370}</style>
+.framey-focus:focus-visible{outline:4px solid #f8d370}
+.framey-dialog{position:fixed;inset:12px;margin:0;z-index:100;overflow:auto;box-shadow:0 0 0 24px #0d1925e6}
+.framey-dialog[hidden]{display:none}</style>
 <p id="framey-error" role="status"></p><div id="framey-toasts" aria-live="polite"></div><div id="framey-root"></div><div id="framey-modal"></div>
 <script id="framey-bundle" type="application/json"''' + module + '''>''' + encoded + '''</script>
 <script src="/framey-runtime/react.js"></script><script src="/framey-runtime/react-dom.js"></script>
@@ -3705,8 +3705,8 @@ class Handler(BaseHTTPRequestHandler):
                    self.send_json({'error':'Framey panel unavailable'}, 404)
            elif path.startswith('/framey/module/'):
                try:
-                    plugin_id, name = path.removeprefix('/framey/module/').split('/', 1)
-                    module = framey_panel.local_module(int(plugin_id), name)
+                    plugin_id, receipt, name = path.removeprefix('/framey/module/').split('/', 2)
+                    module = framey_panel.local_module(int(plugin_id), receipt, name)
                    # The plugin iframe has an opaque origin; only its module
                    # imports need cross-origin access to these public JS files.
                    self.send_bytes(module, 'text/javascript; charset=utf-8', framey=True,
Author	SHA1	Message	Date
SAPHID	9418a340eb	Record v0.4.48 candidate Frame smoke	2026-10-26 15:46:53 +00:00
SAPHID	a8bf01d660	Merge remote-tracking branch 'origin/main' into release/v0.4.48	2026-10-26 15:45:09 +00:00
Alex Southwell	5e3f9559c7	Merge pull request #335 from saphid/feat/framey-mpris-compat Repair official Music Control backend bound-method calls	2026-10-26 15:44:46 +00:00
SAPHID	a31b4a426c	Prepare Frame Control v0.4.48 version	2026-10-26 15:42:38 +00:00
SAPHID	ff465accc5	Merge remote-tracking branch 'origin/main' into feat/framey-mpris-compat	2026-10-26 15:31:25 +00:00
SAPHID	d9c2cc3f27	Repair official Music Control backend bound-method calls	2026-10-26 15:31:06 +00:00
Alex Southwell	910d847573	Merge pull request #333 from saphid/docs/framey-emuchievements-arm Document Emuchievements ARM64 hash helper feasibility	2026-10-26 15:30:25 +00:00
Alex Southwell	89f986b91c	Merge pull request #334 from saphid/docs/v0447-release-evidence Record v0.4.47 release verification	2026-10-26 15:18:31 +00:00
SAPHID	e711945c5a	Record v0.4.47 release verification	2026-10-26 15:09:02 +00:00
SAPHID	3ca8de985e	Record Emuchievements ARM64 helper feasibility	2026-10-26 14:56:14 +00:00
Alex Southwell	035c59ee11	Merge pull request #332 from saphid/release/v0.4.47 Prepare Frame Control v0.4.47 candidate	2026-10-26 14:43:58 +00:00
SAPHID	c687bcc71f	Merge remote-tracking branch 'origin/main' into release/v0.4.47	2026-10-26 14:35:59 +00:00
Alex Southwell	b6f45b287f	Merge pull request #331 from saphid/feat/framey-shotty-python-compat Load Shotty official backend with a scoped Python shim	2026-10-26 14:35:41 +00:00
SAPHID	a77434d91b	Record exact v0.4.47 candidate Frame smoke	2026-10-26 14:25:21 +00:00
SAPHID	e07fa15592	Prepare Frame Control v0.4.47 candidate	2026-10-26 14:23:06 +00:00
SAPHID	1f5b37a755	Merge current main into Shotty compatibility branch	2026-10-26 14:17:13 +00:00
Alex Southwell	77c54c0b01	Merge pull request #330 from saphid/feat/framey-inert-steam-component Show Game Theme Music settings in Framey	2026-10-26 14:16:29 +00:00
SAPHID	d38af757ec	Load Shotty's official backend with a scoped Python shim	2026-10-26 14:04:47 +00:00
SAPHID	211f4fb148	Skip rendered text when replaying private Steam snapshots	2026-10-26 13:46:47 +00:00
SAPHID	72fd779170	Merge remote-tracking branch 'origin/main' into feat/framey-inert-steam-component	2026-10-26 13:45:49 +00:00
SAPHID	286e692147	Render Game Theme Music settings with inert Steam component	2026-10-26 13:45:39 +00:00
Alex Southwell	fe51d29eb4	Merge pull request #329 from saphid/docs/framey-deck-shelves-backend Document Deck Shelves settings backend evidence	2026-10-26 13:44:49 +00:00
SAPHID	4b47c384e6	Document isolated Deck Shelves settings backend check	2026-10-26 13:32:17 +00:00
Alex Southwell	7baafc9a18	Merge pull request #328 from saphid/fix/framey-audit-module-receipts Fix receipt-bound modules in Framey browser audit	2026-10-26 13:22:08 +00:00
SAPHID	b0d8bf3968	Fix receipt-bound modules in Framey browser audit	2026-10-26 13:08:50 +00:00
Alex Southwell	b05a666e50	Merge pull request #327 from saphid/docs/v0446-release-evidence Document v0.4.46 release verification	2026-10-26 12:56:58 +00:00
SAPHID	8feb19a6d3	Document v0.4.46 release verification	2026-10-26 12:49:18 +00:00
Alex Southwell	f84a4da9b1	Merge pull request #326 from saphid/release/v0.4.46 Prepare Frame Control v0.4.46	2026-10-26 12:31:06 +00:00
SAPHID	fc978a2afd	Record exact v0.4.46 candidate Frame smoke	2026-10-26 12:19:32 +00:00
SAPHID	9aff6adcec	Merge remote-tracking branch 'origin/main' into release/v0.4.46	2026-10-26 12:17:07 +00:00
SAPHID	2d8b70d607	Prepare Frame Control v0.4.46 candidate	2026-10-26 12:16:54 +00:00
Alex Southwell	80657b8a8e	Merge pull request #325 from saphid/fix/framey-identical-zip-members Accept identical Decky ZIP members for Free Loader	2026-10-26 12:16:23 +00:00
SAPHID	21b85ba99d	Record full Free Loader regression run	2026-10-26 12:07:13 +00:00
SAPHID	a38d598f14	Merge remote-tracking branch 'origin/main' into fix/framey-identical-zip-members	2026-10-26 12:03:23 +00:00
SAPHID	08567ca571	Accept identical Decky ZIP members for Free Loader	2026-10-26 12:03:13 +00:00
Alex Southwell	4fc5b83873	Merge pull request #324 from saphid/fix/framey-worn-proximity Require proximity telemetry before worn Framey input	2026-10-26 12:00:16 +00:00
Alex Southwell	d96330554a	Merge pull request #323 from saphid/fix/framey-decky-user-path Expose user tools to managed Decky plugins	2026-10-26 11:49:33 +00:00
SAPHID	385ae8290b	Require proximity telemetry before worn Framey input	2026-10-26 11:45:51 +00:00
SAPHID	858edaf7eb	Expose user tools to managed Decky plugins	2026-10-26 11:40:01 +00:00
Alex Southwell	f5213b7c44	Merge pull request #322 from saphid/fix/framey-vr-activity-row Read SteamVR activity from the status row	2026-10-26 11:28:39 +00:00
SAPHID	0219cd10f0	Read SteamVR activity from the status row	2026-10-26 11:18:03 +00:00
Alex Southwell	b0c0599f45	Merge pull request #321 from saphid/docs/v0445-release-evidence Record v0.4.45 release verification	2026-10-26 11:13:32 +00:00
SAPHID	1dcca6d13a	Record v0.4.45 release verification	2026-10-26 11:04:13 +00:00
Alex Southwell	212f0af35c	Merge pull request #320 from saphid/release/v0.4.45 Prepare Frame Control v0.4.45	2026-10-26 10:45:56 +00:00
SAPHID	5da87c8dc0	Record exact v0.4.45 candidate Frame smoke	2026-10-26 10:35:54 +00:00
SAPHID	59ea09325c	Prepare Frame Control v0.4.45 candidate	2026-10-26 10:33:21 +00:00
Alex Southwell	f88e2ed209	Merge pull request #317 from saphid/feat/framey-next-backend-compat Fix Decky activation and confirmation controls in Framey	2026-10-26 10:25:37 +00:00
Alex Southwell	43a6b5e008	Merge pull request #316 from saphid/feat/framey-receipt-modules Bind Framey plugin modules to installed receipts	2026-10-26 10:13:21 +00:00
Alex Southwell	221d2b26ab	Merge pull request #318 from saphid/docs/v0444-release-evidence Record v0.4.44 release verification	2026-10-26 10:10:11 +00:00
SAPHID	087bb1ef9f	Keep updated Framey confirmation dialogs dismissible	2026-10-26 10:10:05 +00:00
SAPHID	0051ac4570	Fix Decky activation and confirmation controls in Framey	2026-10-26 09:32:34 +00:00
SAPHID	dddfc6bea8	Bind Framey plugin modules to installed receipts	2026-10-26 09:16:07 +00:00