diff --git a/.claude/launch.json b/.claude/launch.json
index 45c21fc..55f03cf 100644
--- a/.claude/launch.json
+++ b/.claude/launch.json
@@ -5,7 +5,8 @@
       "name": "tarkov-checker-dev",
       "runtimeExecutable": "pnpm",
       "runtimeArgs": ["dev"],
-      "port": 5173
+      "port": 5173,
+      "autoPort": false
     }
   ]
 }
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
index e68aee6..6fc1b45 100644
--- a/.github/workflows/checks.yml
+++ b/.github/workflows/checks.yml
@@ -57,7 +57,7 @@ jobs:
       # eslint-config-prettier disables format rules in ESLint, so
       # Prettier itself isn't verified by `pnpm lint`. Run it first —
       # a formatting drift fails fast before the heavier eslint pass.
-      - run: pnpm format:check
+      - run: pnpm format
 
       - run: pnpm lint
 
diff --git a/.prettierignore b/.prettierignore
index 3339bba..f542578 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -23,3 +23,7 @@ apps/client/.eslintrc-auto-import.json
 
 # Claude Code local tooling (launch config, vendored skills)
 .claude/**
+
+# Agent instructions — hand-formatted (tables, aligned lists), owned by
+# whoever edits them, not by prettier
+CLAUDE.md
diff --git a/CLAUDE.md b/CLAUDE.md
index eb73c66..0197da7 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -5,9 +5,10 @@
 - `apps/desktop` — Tauri 2 wrapper. The production artifact: Rust
   watcher/config pipeline (`src-tauri/src/server/`), the Tauri IPC
   commands the webview calls, AND an in-process HTTP server (axum) on
-  `127.0.0.1:47474` exposing `/api/ping`, `/api/config` (GET+PUT) and
-  `/events` (SSE). Single 6 MB `.exe` that ships as both the overlay
-  and the local HTTP backend for any browser pointed at the same
+  `0.0.0.0:47474` (binds all interfaces, trust model: same Wi-Fi = trusted)
+  exposing `/api/ping`, `/api/config` (GET+PUT), `/api/hotkeys` (GET+PUT,
+  +suspend/resume) and `/events` (SSE). Single 6 MB `.exe` that ships as both
+  the overlay and the local HTTP backend for any browser pointed at the same
   origin. See "In-process HTTP server" below.
 - `apps/client` — Vue + Leaflet map. Two transports, one codebase.
   Inside the Tauri webview: `invoke(...)` + `listen('position', ...)`.
@@ -175,38 +176,64 @@ key back in the running app.
 
 ## Map rendering layers
 
-`apps/client/src/features/map/` is split into two sibling folders by
-ownership:
+`apps/client/src/features/map/` is split into three sibling folders:
 
 - `composables/` — **framework hooks** for Leaflet/Vue plumbing:
-  `useLeafletMap`, `useFloorSwitcher`. Nothing here knows about extracts,
-  player markers, or future quest markers — pure map/Leaflet glue.
-- `layers/<name>/` — **domain layers** rendered on top of the map. Each
-  layer fully owns its concerns: data adapter, icon HTML, tooltip HTML,
-  the composable that wires it into Leaflet. All layers use a registry
-  pattern: `layers/registry.ts` exports `registerMapLayer()` and
-  `useMapLayers()`. Currently:
-
-      layers/extracts/
-        useExtractsLayer.ts     # Leaflet/Vue glue, data load, marker sync
-        icon.ts                 # slice geometry + makeIcon (composite via CSS clip-path)
-        tooltip.ts              # buildTooltipHtml + escapeHtml + sortedEntries
-        index.ts                # registerMapLayer call
-      layers/player/
-        usePlayerLayer.ts       # player position marker + follow logic
-        index.ts                # registerMapLayer call
-      layers/airdrop/
-        useAirdropLayer.ts      # purple uncertainty circle around the predicted drop
-        index.ts                # registerMapLayer call
-
-  Each `index.ts` calls `registerMapLayer({ id, mount })` at module load;
+  `useLeafletMap`, `useFloorSwitcher`, `useLayerVisibility`, `useRailObstacle`
+  (the rail rect edge-indicator layers wrap around). Nothing here knows about
+  extracts, player markers, or future quest markers — pure map/Leaflet glue.
+- `components/` — **UI surfaces** mounted by the page:
+  - `LayerRail.vue` — on-map left rail (vertically centered). Top icon = base map
+    selector flyout (MapSection component). Below that, one icon per layer **category**
+    (derived from registry `subgroup`: today only `player`, with `loot`/`quests`
+    dimmed future icons). Clicking a category icon opens a flyout listing its
+    layers: each row has a visibility `ToggleSwitch`, layer name, and a gear button
+    that expands that layer's settings component inline. Floor stepper at the rail's
+    bottom (multi-floor maps only) is a vertical ▲/level/▼. Rail hides when the
+    overlay is click-through-locked. When locked on a multi-floor map, a compact
+    read-only floor chip appears bottom-left. Flyouts position relative to the rail
+    via CSS `position: absolute; left: full; top: 1/2` (NOT `position: fixed`
+    which drifted in the Tauri WebView2 overlay).
+  - `MapView.vue` — mounts the Leaflet container, the LayerRail, and layer
+    composables. Wires Alt+mouse wheel (captured, throttled ~120ms) to step
+    floors instead of zooming on multi-floor maps.
+- `layers/<name>/` — **domain layers** rendered on top of the map. Each layer fully
+  owns its concerns: data adapter, icon HTML, tooltip HTML, the composable that
+  wires it into Leaflet. All layers use a registry pattern: `layers/registry.ts`
+  exports `registerMapLayer()` and `useMapLayers()`. Currently:
+
+        layers/extracts/
+          useExtractsLayer.ts     # Leaflet/Vue glue, data load, marker sync
+          icon.ts                 # slice geometry + makeIcon (composite via CSS clip-path)
+          tooltip.ts              # buildTooltipHtml + escapeHtml + sortedEntries
+          useEdgeIndicators.ts    # off-screen extract arrows; wraps left edge around the rail
+          index.ts                # registerMapLayer call
+        layers/player/
+          usePlayerLayer.ts       # player position marker + recentering on follow
+          index.ts                # registerMapLayer call
+        layers/airdrop/
+          useAirdropLayer.ts      # purple uncertainty circle around the predicted drop
+          index.ts                # registerMapLayer call
+
+  Each `index.ts` calls `registerMapLayer({ id, mount, category, order, titleKey,
+settingsComponent? })` at module load (the rail metadata lives here — there is
+  no second registry for layers);
   `main.ts` loads all index files via `import.meta.glob('@/features/map/layers/*/index.ts', { eager: true })`.
   `MapView.vue` reads the registry with `useMapLayers()` and calls
-  `mount(ctx)` for each layer in setup(). When quest markers (or anything
-  else) get added later, create `layers/quests/{useQuestMarkers,icon,tooltip,index}.ts`
-  following the same pattern — no manual list to update. Airdrop's state
-  machine, tracker, and banner live in `features/airdrop/` — only the
-  Leaflet circle moved here. See "Airdrop feature" below.
+  `mount(ctx)` for each layer in setup(). `MapLayerContext` (in `layers/registry.ts`)
+  includes `visible: Ref<boolean>` driven by the LayerRail toggle; the layer composable
+  watches it and adds/removes its Leaflet root accordingly. When quest markers (or
+  anything else) get added later, create `layers/quests/{useQuestMarkers,icon,tooltip,index}.ts`
+  following the same pattern — no manual list to update. Airdrop's state machine,
+  tracker, and banner live in `features/airdrop/` — only the Leaflet circle moved here.
+  See "Airdrop feature" below.
+
+**Off-screen extract arrows** (`useEdgeIndicators.ts`): arrows render on the viewport
+edge pointing at extracts outside the visible bounds. On the overlay, the left edge
+wraps around the LayerRail — a left-edge arrow whose y falls within the rail's
+vertical span is pushed out to the rail's right edge (RAIL_GAP px beyond). Measured
+each frame via `.layer-rail` rect so arrows flow dynamically as the rail animates
+in/out on lock transitions.
 
 Extract markers are `L.divIcon` instances (not `L.icon`) — the composite
 PNG split via CSS `clip-path: polygon(...)` is built inline as HTML.
@@ -234,9 +261,8 @@ icon's top edge gives a few pixels of overlap for visual cohesion.
 marker — an SVG arrow (rotated by `yaw + mapRotation + yawOffset`) or
 a circle fallback when `yaw === null`. The marker isn't created until
 the first position arrives. On every position update with changed
-`(x, z, yaw)` and `playerFollow !== 'off'`, the map recenters and zooms
-to `initialZoom + FOLLOW_ZOOM_DELTA[mode]` — that's why `initialZoom`
-sits in `MapLayerContext`.
+`(x, z)` and `playerFollow === 'on'`, the map recenters (zoom stays
+fixed) — that's why `initialZoom` sits in `MapLayerContext`.
 
 ## Airdrop feature
 
@@ -283,11 +309,31 @@ Two surfaces read/write this state:
   path without a restart.
 - **HTTP**: `GET /api/config` / `PUT /api/config` on the in-process
   axum server (see "In-process HTTP server" below). Same behaviour as
-  the IPC commands, same `ResolvedPaths` shape.
-
-The HTTP server binds on `127.0.0.1:47474` — fixed port, no TCP
-exposure beyond loopback. LAN exposure is a future opt-in toggle
-(see "Future architecture").
+  the IPC commands, same `ConfigResponse` shape.
+
+The config get/update no longer returns bare `ResolvedPaths` — it returns
+`ConfigResponse` (`paths.rs`), which `#[serde(flatten)]`s `ResolvedPaths` and
+appends `deleteScreenshots: bool`. Wire shape is
+`{ gameDir, logsDir, screenshotsDir, deleteScreenshots }`, mirrored by
+`serverConfigResponseSchema` in `@shared/config-api`. `deleteScreenshots` is an
+opt-in (default false) flag persisted in `config.json` alongside the path
+overrides: when on, the screenshot watcher sends each parsed Tarkov screenshot
+to the **OS recycle bin** (`trash` crate) right after broadcasting its
+position — the image is never used beyond its filename, so nothing is lost, and
+the folder stops filling up over long sessions. Only files whose name parses as
+a Tarkov position screenshot are touched (`should_trash` in `screenshots.rs`);
+unrelated files the user dropped in the folder are never deleted. The flag
+reaches the watcher via a shared `Arc<AtomicBool>` on `WatcherSlot`
+(`set_delete_screenshots`), so toggling it takes effect live; both PUT paths
+(`update_config` IPC + `put_config_http`) set it before `apply_resolved`. UI is
+a `ToggleSwitch` in the Paths settings section (saves immediately, no Save
+button), so it's configured on the machine that owns the screenshots folder.
+
+The HTTP server binds on `0.0.0.0:47474` — all interfaces, fixed port. Same-Wi-Fi
+machine browsers reach it via localhost/127.0.0.1 loopback; LAN phones reach it
+via the LAN IP. Trust model: same Wi-Fi = trusted (gated by `CorsLayer` for
+browser drive-by callers; LAN curl-equivalents unfiltered by design). See
+"In-process HTTP server" section for architectural reasoning.
 
 ## User settings
 
@@ -301,10 +347,11 @@ Persisted state lives in **per-feature** Pinia stores, not one big store:
     the `--extract-label-size` CSS variable on `<html>` from
     `useExtractsLayer` in `layers/extracts/useExtractsLayer.ts` — which also
     re-binds tooltips so Leaflet recomputes positions for the new height).
-  - `playerFollow` — `"off" | "sm" | "md" | "lg"` — auto-recenter + zoom on
-    every fresh position update. Wired in `layers/player/usePlayerLayer.ts`;
-    only re-centers when `(x, z)` actually changes (skips spam updates when
-    the player stands still). Zoom step: `initialZoom + FOLLOW_ZOOM_DELTA[mode]`.
+  - `edgeIndicators` — boolean, default false. Off-screen extract arrows; opt-in.
+  - `playerFollow` — `"off" | "on"` — auto-recenter map on every fresh position
+    update. Wired in `layers/player/usePlayerLayer.ts`; only recenters when
+    `(x, z)` actually changes (skips spam updates when the player stands still).
+    Zoom stays fixed at `initialZoom`.
   - `autoMapSwitch` — boolean, default `true`. When on, incoming
     `map-change` events from the logs watcher flip `mapCode` to whatever
     the game just loaded (resolved through `canonicalMapCode()` so
@@ -313,15 +360,25 @@ Persisted state lives in **per-feature** Pinia stores, not one big store:
     are silently dropped with one `console.warn`. Wiring lives in
     `features/map/composables/useAutoMapSwitch.ts`, mounted once at
     `App.vue` root.
+- **Per-layer visibility**: `composables/useLayerVisibility.ts` exports a
+  function that returns a shared `persistedRef('tc.layer.<id>.visible', z.boolean(), true)`
+  per layer id (module-level singleton). The LayerRail toggle and the layer
+  composable read/write the same ref. Consumed by `MapLayerContext.visible`
+  in `layers/registry.ts`.
 - `apps/client/src/features/i18n/store.ts` — `apiLang` (`"en" | "ru"`).
   The store's `watch(apiLang, ..., {immediate: true})` mirrors the value
   into vue-i18n's `locale`; `main.ts` calls `useI18nStore()` eagerly after
   `app.use(createPinia())` so the persisted language is applied before any
   component reads `t()`.
-- `apps/client/src/features/hotkeys/store.ts` — per-action hotkey combos.
+- `apps/client/src/features/hotkeys/store.ts` — thin sync layer over the
+  **backend-owned** combos: `lockHotkey` stays a client `persistedRef`
+  (overlay-only), the five forwarded actions load from the backend
+  (`fetchHotkeys`) and `setAction` PUTs on change. See "Backend-owned
+  hotkeys" below.
 - `apps/client/src/features/overlay/store.ts` — Tauri-only:
   `alwaysOnTop`, `opacity` (0.3–1), `mapOpacity` (0–1), `zoom`
-  (`"75" | "100" | "125" | "150"`), plus a deliberately session-only
+  (`"75" | "100" | "125" | "150"`), `minimizeToTray` (default false; when on,
+  ✕ hides to tray instead of closing), plus a deliberately session-only
   `clickThrough` (plain `ref()`, not `persistedRef` — see note below).
 - `apps/client/src/features/airdrop/store.ts` — `dropMarkerRadius` (game
   meters, slider-bound in Settings). Wraps the airdrop state machine —
@@ -331,40 +388,105 @@ Each store uses `persistedRef` from `@/shared/persisted-store` with its
 own key (`tc.<feature>.<field>`) — corrupt persisted data falls back to
 defaults silently.
 
-**Session-only state.** `overlayClickThrough` intentionally does NOT
-use `persistedRef`. Booting into a locked overlay with a broken hotkey
-would be unrecoverable, so `App.vue` resets the value to `false` on
-every Tauri startup. Reach for plain `ref()` (not `persistedRef`) any
-time boot-time recoverability matters more than user-visible
-continuity; default to `persistedRef` everywhere else.
-
-## Settings UI registry
-
-Settings sections use a registry pattern similar to map layers: each feature
-that owns settings registers its UI section via `registerSettingsSection()`.
-
-- `features/settings/registry.ts` — `registerSettingsSection()` and
-  `useSettingsSections(group)`. Visibility logic: `'always'` (desktop +
-  phone, default), `'tauri'` (overlay only), `'desktop-or-tauri'` (phone at
-  ≥640px or overlay). Order uses multiples of 10. Currently:
-  - main: 10 map, 20 extracts, 30 player, 40 airdrop (tauri-only), 50 overlay (tauri-only), 60 hotkeys (tauri-only)
-  - system: 10 language, 20 paths (desktop-or-tauri)
-- `features/<name>/settings.ts` — each feature with settings calls
-  `registerSettingsSection({ id, group, order, visible, component })` at
-  module load. Currently: `map`, `airdrop`, `overlay`, `hotkeys`, `i18n`,
-  `server` (each maps to a section component under
-  `features/settings/sections/`).
-- `main.ts` loads all registration files via
-  `import.meta.glob('@/features/*/settings.ts', { eager: true })`.
-- `SettingsPanel.vue` — gear icon in the top-right cluster next to the
-  transport-status pill (`App.vue`), opens a PrimeVue `Drawer` (right-side on
-  desktop, `position="full"` on `<640px`). Iterates `useSettingsSections('main')`
-  and `useSettingsSections('system')` to build the drawer — no hard-coded list
-  of sections.
+**Session-only state.** `clickThrough` intentionally does NOT use `persistedRef`.
+Booting into a locked overlay with a broken hotkey would be unrecoverable, so
+`App.vue` resets the value to `false` on every Tauri startup. Reach for plain
+`ref()` (not `persistedRef`) any time boot-time recoverability matters more than
+user-visible continuity; default to `persistedRef` everywhere else.
+
+## Settings & layer registries
+
+**Two SEPARATE registries, one per surface — no shared-id matching across them.**
+
+- **Map-layer registry** (`features/map/layers/registry.ts`) — the single source
+  of truth for layers. `registerMapLayer({ id, mount, category, order, titleKey,
+settingsComponent?, availability? })`; `useMapLayers()` reads them. Each layer
+  self-describes its rail `category` (`'player' | 'loot' | 'quests'`), `order`,
+  display `titleKey`, and optional inline `settingsComponent`. Layers register in
+  their own `layers/<name>/index.ts` (auto-loaded via the layers glob). Consumed by
+  the on-map **LayerRail** (`features/map/components/LayerRail.vue`): a left rail
+  with the base map selector at the top (a direct `MapSection` import — it's a
+  prerequisite, not a layer), then one icon per category (membership derived from
+  each layer's `category`; empty categories like loot/quests render as dimmed
+  future placeholders). A category flyout lists its layers, each with a visibility
+  toggle (`useLayerVisibility`) + the layer's `settingsComponent` inline via a gear.
+  `CATEGORY_META` in the rail is presentation-only (icon + which futures to tease),
+  NOT the catalogue.
+- **Settings-section registry** (`features/settings/registry.ts`) — **system/app
+  settings only** (no layer concept; no groups/subgroups). `registerSettingsSection({
+id, order, titleKey, visible?, component })`; `useSettingsSections()` returns them
+  filtered by `visible` (`'always'` | `'tauri'` | `'desktop-or-tauri'` | `'browser'`,
+  where `'browser'` = `!isTauri`) and sorted by
+  `order`. Registered in `features/<name>/settings.ts` (auto-loaded via
+  `import.meta.glob('@/features/*/settings.ts', { eager: true })`). Currently: 10
+  overlay (tauri), 20 hotkeys (always; rows read-only on a phone — no keyboard
+  to record), 25 display (browser), 30 language,
+  40 paths (desktop-or-tauri), 50 pairing (tauri). Consumed by the gear **drawer**
+  (`SettingsPanel.vue`): a **non-modal** PrimeVue `Drawer` (right on desktop,
+  bottom-sheet on `<640px`) rendering a single flat **Accordion**; open-panel state
+  persists in `tc.settings.open`.
 
 Faction colours come from `FACTION_COLORS` in `packages/shared/src/maps.ts`
 so icons and tooltip stripes never drift across components.
 
+## Mobile display (browser / phone)
+
+`apps/client/src/features/display/` holds the browser/phone fullscreen affordance.
+Browser-only — the Display settings section registers with `visible: 'browser'`
+(`!isTauri`); the frameless Tauri overlay has no browser chrome, so it's moot there.
+
+- **Fullscreen** lives ONLY in the Display settings section
+  (`components/DisplaySection.vue`) — a `ToggleSwitch` bound to live fullscreen
+  state via `composables/useFullscreenToggle.ts` (VueUse `useFullscreen` on
+  `document.documentElement`, so the address bar collapses). Android/desktop get a
+  real toggle; iOS Safari has **no Fullscreen API**, so on iOS the row shows an
+  "Add to Home Screen" hint instead (the PWA `display: standalone` route is the
+  only chrome-free path on iPhone). The whole row hides once installed as a PWA
+  (`isStandalone`). The toggle is `.catch(() => undefined)` — `requestFullscreen`
+  rejects in an iframe and there's nothing actionable. (There is no on-map
+  fullscreen button — it was tried in the top-right cluster but removed to keep
+  the bar uncluttered on narrow phones; see "Top bar" below.)
+- `composables/useDisplayEnv.ts` exposes `isIos` (UA incl. iPadOS-as-Mac) and
+  `isStandalone` (`matchMedia('(display-mode: standalone)')` + `navigator.standalone`).
+
+**Top bar (browser).** The connection-status dot, the map name (only ≥380px), and
+the two in-game clocks all live in the always-visible left chip
+(`TarkovTimeChip.vue`), so the top-right browser cluster is just the settings gear
+— this keeps the bar from overflowing on a 320px-wide phone (iPod touch). The clock
+samples via `requestAnimationFrame` and swaps its ref only when the shown value
+changes (in-game time runs 7×, so a fixed interval visibly stutters the seconds).
+
+**Keep-awake was considered and deliberately dropped.** There is no reliable web
+way to keep a mobile screen awake over plain HTTP: the Screen Wake Lock API needs a
+secure context (HTTPS / `localhost` — neither reaches a LAN phone, and it's absent
+entirely on iOS < 16.4), and the muted/unmuted looping-`<video>` trick no longer
+keeps the screen on under current iOS **or** Android (verified on iPod touch iOS 15
+
+- Android). The honest fallback is the OS auto-lock setting. Don't re-add a JS
+  keep-awake hack unless serving over HTTPS becomes viable.
+
+**PWA manifest** (`apps/client/public/manifest.webmanifest` + `<link rel="manifest">`
+and the `apple-mobile-web-app-*` / `mobile-web-app-capable` meta in `index.html`):
+`display: standalone`, icon = the existing `favicon.svg` (`sizes: "any"`).
+`start_url`/`scope` are `/`, correct for the phone (`:5173`/`:47474`) and the Tauri
+release (base `/`). The hosted **GitHub Pages** build serves under base
+`/tarkov-checker/`, so its `start_url`/`scope` would mismatch — the static manifest
+isn't templated by Vite. Pages PWA install is a secondary path; template the
+manifest if it ever matters. iOS `apple-touch-icon` ideally wants a PNG — pointing
+it at the SVG works on Android, but iPhone may fall back to a page screenshot for
+the home-screen icon; rasterising `favicon.svg` to PNG is an open follow-up.
+
+**PWA manifest** (`apps/client/public/manifest.webmanifest` + `<link rel="manifest">`
+and the `apple-mobile-web-app-*` / `mobile-web-app-capable` meta in `index.html`):
+`display: standalone`, icon = the existing `favicon.svg` (`sizes: "any"`).
+`start_url`/`scope` are `/`, correct for the phone (`:5173`/`:47474`) and the Tauri
+release (base `/`). The hosted **GitHub Pages** build serves under base
+`/tarkov-checker/`, so its `start_url`/`scope` would mismatch — the static manifest
+isn't templated by Vite. Pages PWA install is a secondary path; template the
+manifest if it ever matters. iOS `apple-touch-icon` ideally wants a PNG — pointing
+it at the SVG works on Android, but iPhone may fall back to a page screenshot for
+the home-screen icon; rasterising `favicon.svg` to PNG is an open follow-up.
+
 ## Desktop overlay (Tauri)
 
 The Tauri 2 window is configured as a **frameless, transparent overlay**
@@ -384,34 +506,63 @@ is a no-op so the same code path serves both.
 
 **Overlay controls** (only rendered when `isTauri`):
 
-- **Drag region** — the transport-status pill in `App.vue`'s top-right cluster.
-  Uses an explicit `@mousedown` handler that calls `getCurrentWindow().
-startDragging()` rather than `data-tauri-drag-region` attribute, which
-  is flaky on `decorations: false + transparent: true` windows. Child
-  `<i>` and `<span>` inside the pill have `pointer-events: none` so the
-  drag start always lands on the pill itself.
-- **Close** — red ✕ button next to the gear; runs through a PrimeVue
-  `ConfirmDialog` so an accidental click can't kill the session (close
-  sits right next to settings).
-- **Lock / click-through** — bottom-right corner: a `[Ctrl][Alt][L]` Kbd
-  hint plus a lock button (`pi-lock-open` ↔ `pi-lock`). State lives on
-  `overlayClickThrough` in the store. Click on the open lock locks the
-  window; **only the global hotkey can unlock it**, because once
-  click-through is on the lock button itself isn't clickable. App.vue
-  _always_ resets `overlayClickThrough` to `false` on Tauri startup —
-  the locked state intentionally doesn't persist across sessions, so
-  the app can't boot into an unrecoverable lockout.
-- **Opacity slider** — calls `Window.setOpacity()` (Windows Layered
-  Window API). If the call rejects (the permission `core:window:
-allow-set-opacity` doesn't exist in Tauri 2.11.x), the composable
-  silently falls back to `document.documentElement.style.opacity` so the
-  slider remains visually responsive.
-- **Zoom** — `WebviewWindow.setZoom(factor)`.
-
-**Global shortcut** is `tauri-plugin-global-shortcut` (Rust crate +
-`@tauri-apps/plugin-global-shortcut` npm). Registered in `App.vue`'s
-`onMounted` with combo `"CommandOrControl+Alt+L"`. Handler fires on
-both `Pressed` and `Released` — toggle only on `Pressed`.
+**Unlocked state:**
+
+- **Drag region** — the entire top bar (OverlayHeader.vue) is clickable and grabbable.
+  Uses an explicit `@mousedown` handler that calls `getCurrentWindow().startDragging()`
+  rather than `data-tauri-drag-region` attribute, which is flaky on `decorations: false +
+transparent: true` windows. Idle, only a small nub shows; hovering/dragging reveals
+  two separate zones as flex siblings: a drag pill (left, flex-1, visual only with "move"
+  label) and the control cluster (right, auto-width with pointer events). The transport
+  status dot, settings gear, and close button all live in the cluster; only the drag
+  pill is pointer-disabled.
+- **Close** — red ✕ button. With `minimizeToTray` off (default), runs through a
+  PrimeVue `ConfirmDialog` so an accidental click can't kill the session. With it on,
+  hides the window to the system tray (reversible via the tray's Show item) with no
+  confirm.
+- **Settings gear** — opens the system settings drawer (right-side desktop, bottom-sheet
+  phone/overlay).
+- **Opacity slider** — in the gear drawer (`OverlaySection.vue`), calls
+  `Window.setOpacity()` (Windows Layered Window API). If the call rejects (the permission
+  `core:window:allow-set-opacity` doesn't exist in Tauri 2.11.x), the composable
+  silently falls back to `document.documentElement.style.opacity` so the slider remains
+  visually responsive.
+- **Zoom** — in the gear drawer, calls `WebviewWindow.setZoom(factor)`.
+
+**Locked state (click-through):**
+
+- **Rails & controls hide** — the top band vanishes, the LayerRail hides, and animated
+  borders disappear for a clean map-only view.
+- **Read-outs stay visible** — the clock+location pill (TarkovTimeChip, top-left),
+  the connection status dot (OverlayHeader), the floor stepper chip (LayerRail,
+  bottom-left on multi-floor maps), and the lock hotkey hint (OverlayLockIndicator,
+  bottom-right) remain always-visible.
+- **Unlock** — bottom-right corner: a `[Ctrl][Alt][L]` Kbd hint plus a lock button
+  (`pi-lock-open` ↔ `pi-lock` in OverlayLockIndicator). State lives on `clickThrough`
+  in the store. Click on the open lock or press the hotkey to toggle. **Only the
+  global hotkey can unlock it** because once click-through is on the lock button itself
+  isn't clickable (intentional escape hatch). App.vue _always_ resets `clickThrough` to
+  `false` on Tauri startup — the locked state intentionally doesn't persist across
+  sessions, so the app can't boot into an unrecoverable lockout.
+
+**Lock global shortcut** is the ONLY client-registered hotkey:
+`useGlobalShortcut` (via `@tauri-apps/plugin-global-shortcut`) binds
+`"CommandOrControl+Alt+L"` in `App.vue` to toggle click-through. Kept
+client-side on purpose — it's an overlay window op with no browser
+meaning, and the proven plugin path preserves the recovery route out of
+a click-through lockout. Handler fires on both `Pressed` and `Released`
+— toggle only on `Pressed`. **Every other hotkey is backend-owned** —
+see "Backend-owned hotkeys" below.
+
+**Floor switching** (multi-floor maps only) — three paths:
+
+- **GUI**: the floor stepper (▲/▼) at the bottom of the LayerRail.
+- **Hotkey**: backend-owned `floor-up`/`floor-down` actions (always global, even while
+  the game is focused).
+- **Quick**: Alt + mouse wheel over the map (MapView.vue, captured in the capture phase
+  before Leaflet's wheel-zoom, throttled ~120ms so trackpad doesn't skip floors).
+  The floor stepper reads the current floor; locking the overlay hides the rail's
+  stepper but keeps the read-only bottom-left floor chip, and hotkeys still work.
 
 **Capabilities** (`apps/desktop/src-tauri/capabilities/default.json`)
 must include the privileged window ops explicitly — `core:default`
@@ -422,7 +573,13 @@ core:window:allow-set-always-on-top
 core:window:allow-set-ignore-cursor-events
 core:window:allow-close
 core:window:allow-start-dragging
+core:window:allow-hide
+core:window:allow-show
+core:window:allow-set-focus
 core:webview:allow-set-webview-zoom
+core:tray:default
+core:menu:default
+core:app:allow-default-window-icon
 global-shortcut:allow-register
 global-shortcut:allow-unregister
 global-shortcut:allow-is-registered
@@ -449,17 +606,17 @@ axum-based HTTP server alongside the Tauri IPC layer, so the same
 process backs both the webview (via IPC) and any browser tab on the
 machine (via HTTP). One source of state, two transports.
 
-| Module                  | Role                                                                                               |
-| ----------------------- | -------------------------------------------------------------------------------------------------- |
-| `http_server.rs`        | axum routes, CorsLayer, SSE handler, listens on `0.0.0.0:47474`                                    |
-| `server/screenshots.rs` | `notify-debouncer-full` watcher (250 ms `awaitWriteFinish` equivalent); parses filename → position |
-| `server/logs.rs`        | poll-tails latest `log_*/application_NNN.log`; emits `map-change` on `rcid:` / `Location:` hits    |
-| `server/paths.rs`       | env → manual override → `winreg` auto-detect; returns `ResolvedPaths`                              |
-| `server/config.rs`      | reads/writes `%APPDATA%/tarkov-checker/config.json`; rejects UNC paths                             |
-| `server/events.rs`      | `ServerEvent` enum + `tokio::sync::broadcast` channel for HTTP-side fan-out                        |
-| `watcher.rs`            | `WatcherSlot` state holder + `apply_resolved` that atomically swaps watcher handles                |
-| `lan.rs`                | LAN IP detection for the QR pairing flow (multi-NIC heuristic — see `detect_lan_ip`)               |
-| `commands.rs`           | Tauri `#[tauri::command]` adapters mirroring the HTTP routes + `pairing_qr`                        |
+| Module                  | Role                                                                                                                                                  |
+| ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `http_server.rs`        | axum routes, CorsLayer, SSE handler, listens on `0.0.0.0:47474`                                                                                       |
+| `server/screenshots.rs` | `notify-debouncer-full` watcher (250 ms `awaitWriteFinish` equivalent); parses filename → position; opt-in recycle-bin delete after parse (see below) |
+| `server/logs.rs`        | poll-tails latest `log_*/application_NNN.log`; emits `map-change` on `rcid:` / `Location:` hits                                                       |
+| `server/paths.rs`       | env → manual override → `winreg` auto-detect; returns `ResolvedPaths`                                                                                 |
+| `server/config.rs`      | reads/writes `%APPDATA%/tarkov-checker/config.json`; rejects UNC paths                                                                                |
+| `server/events.rs`      | `ServerEvent` enum + `tokio::sync::broadcast` channel for HTTP-side fan-out                                                                           |
+| `watcher.rs`            | `WatcherSlot` state holder + `apply_resolved` that atomically swaps watcher handles                                                                   |
+| `lan.rs`                | LAN IP detection for the QR pairing flow (multi-NIC heuristic — see `detect_lan_ip`)                                                                  |
+| `commands.rs`           | Tauri `#[tauri::command]` adapters mirroring the HTTP routes + `pairing_qr`                                                                           |
 
 **Trust model: same Wi-Fi = trusted.** The helper always binds
 `0.0.0.0:47474`. No bearer-token auth — browser drive-by callers are
@@ -473,11 +630,18 @@ for the architectural reasoning.
 - `GET /api/config` — current `ResolvedPaths`. Origin-allowlisted via
   `CorsLayer` (Vite dev `:5173`, hosted GitHub Pages); same
   JSON shape as the Tauri `get_config` IPC command.
-- `PUT /api/config` — apply `ConfigPatch`, re-run `apply_resolved`,
-  return the new `ResolvedPaths`. UNC → 400 with `{error: "..."}`.
+- `PUT /api/config` — apply `ConfigPatch` (path overrides +
+  `deleteScreenshots`), re-run `apply_resolved`, return the new
+  `ConfigResponse`. UNC → 400 with `{error: "..."}`.
+- `GET /api/hotkeys` — backend-owned combos (`HotkeyConfig`).
+- `PUT /api/hotkeys` — apply `HotkeyPatch`, (re)register OS hotkeys,
+  return the EFFECTIVE config (a combo that can't be claimed reverts).
+  Unparseable combo → 400. See "Backend-owned hotkeys".
+- `POST /api/hotkeys/{suspend,resume}` — drop / re-claim the OS binds
+  while the settings recorder captures a combo (204).
 - `GET /events` — Server-Sent Events stream. `ServerEvent` (tagged
-  enum) frames; one `data: { type: "position"|"map-change", ... }`
-  per watcher emission. Keep-alive `: ping` every 25 s.
+  enum) frames; one `data: { type: "position"|"map-change"|"command", ... }`
+  per watcher / hotkey emission. Keep-alive `: ping` every 25 s.
 
 Events are fan-out twice in parallel by each watcher emit-site:
 
@@ -503,12 +667,69 @@ Frontend chooses the transport in two places only:
 
 `PositionPayload` (struct in `screenshots.rs`) and `MapChangePayload`
 (struct in `logs.rs`) on the Rust side mirror `PositionMessage` and
-`MapChangeMessage` from `packages/shared/src/ws-messages.ts`. The
+`MapChangeMessage` from `packages/shared/src/sse-messages.ts`. The
 HTTP-side `ServerEvent` enum (in `server/events.rs`) is the tagged-
 union wire format for SSE. Adding a new event type touches four
 declarations (TS schema, TS discriminated union, Rust payload struct,
-new `ServerEvent` variant); the file is still called `ws-messages.ts`
-for historical reasons (was the WS schema before the SSE migration).
+new `ServerEvent` variant) — e.g. the `hotkeys` config-resync event below.
+(The file was `ws-messages.ts` before the SSE migration; renamed to
+`sse-messages.ts`.)
+
+## Backend-owned hotkeys
+
+The backend is the single owner of the five forwarded hotkeys (`zoom-in`,
+`zoom-out`, `floor-up`, `floor-down`, `airdrop`). It registers them as
+**OS-global** shortcuts (fire even while the game is focused) and on a
+press broadcasts `ServerEvent::Command { action }` so EVERY client —
+overlay webview, browser, LAN phone — performs the action. The old
+focus-required `useBrowserShortcut` and per-client `useGlobalShortcut`
+wiring for these is gone; only the overlay **lock** combo stays
+client-registered (see "Desktop overlay").
+
+- Combos persist in `%APPDATA%/tarkov-checker/hotkeys.json` via
+  `server/hotkeys.rs` (`HotkeyStore`, sibling to `config.json`). Defaults
+  match the client's historical `tc.hotkeys.*` so an un-customised install
+  is unchanged; the client migrates customised localStorage values up once
+  (`tc.hotkeys.migrated`).
+- Registration lives in `src/hotkeys.rs` behind one `HotkeyController`
+  trait, with two impls that are **never** used together (the windowed app
+  and headless backend are mutually exclusive — both bind :47474):
+  - `TauriHotkeys` (`run()`): delegates to `tauri-plugin-global-shortcut`.
+    The five combos are registered via the **plugin Builder**
+    (`.with_shortcuts(...).with_handler(...)`) so registration happens on
+    Tauri's main thread without the `run_on_main_thread` deadlock that
+    registering inside our own `setup` hook would hit; a press-handler
+    reads an `Arc<Mutex<id→action>>` map and emits `command`.
+  - `StandaloneHotkeys` (`run_headless()`): there is no Tauri event loop,
+    so it owns a dedicated OS thread that creates a
+    `global_hotkey::GlobalHotKeyManager` and runs its **own Win32
+    `PeekMessage` pump**, reading `WM_HOTKEY` directly. Required because
+    `global-hotkey` needs a message pump on the manager's thread; the doc
+    even says so. It does NOT use `GlobalHotKeyEvent::set_event_handler`.
+- **Do not** run a standalone `global-hotkey` manager and the Tauri plugin
+  in the SAME process: the plugin installs a process-global
+  `GlobalHotKeyEvent::set_event_handler` (`OnceCell`), so a second
+  manager's events would route to the plugin's handler (which doesn't know
+  the ids) and the `receiver()` channel would get nothing. The two impls
+  above sidestep this by never coexisting.
+- The settings recorder brackets capture with the `HOTKEY_SUSPEND/RESUME`
+  window events; `useHotkeysSync` (App.vue) bridges them to
+  `POST /api/hotkeys/{suspend,resume}` so the backend drops its OS binds
+  and the pressed combo reaches the page/webview to be re-recorded (the
+  same events still drive the client-side lock shortcut).
+- Wire parity follows the same 4-declaration rule as other events:
+  `commandMessage` (zod) + union in `sse-messages.ts`, `ServerEvent::Command`
+  - `HotkeyAction` (kebab-case) in `server/events.rs`. The client dispatches
+    `command` in `pages/index.vue` (`useServerEvent('command', …)`) to
+    `mapRef`/`airdropStore`.
+- **Config re-sync:** a rebind broadcasts `ServerEvent::Hotkeys { config }`
+  (`hotkeysMessage` in `sse-messages.ts`) from BOTH PUT paths —
+  `put_hotkeys_http` (`state.event_tx`) and the `update_hotkeys` IPC command
+  (`slot.event_sender()`, same broadcast channel) — so OTHER clients re-sync
+  over SSE; the originator already has the effective config from its response.
+  `useHotkeysSync` applies it via `store.applyConfig`. This is why the
+  hotkeys section is `visible: 'always'` (read-only on a phone — no keyboard
+  to record): the phone's list stays live with what the overlay set.
 
 The logs watcher (`server/logs.rs`) tails the **latest** `log_*/`
 session folder under `logsDir` — picked by sort order (timestamps in
@@ -615,9 +836,28 @@ DeviceGuard').SecurityServicesRunning` → should be empty/`0`. VBS
 
 7. **Icons must exist for `tauri-build` on Windows.** At minimum
    `apps/desktop/src-tauri/icons/icon.ico` must be present (the Windows
-   Resource step depends on it). Placeholder PNGs at 32×32, 128×128,
-   128×128@2x are also referenced in `tauri.conf.json` and ship today
-   as solid purple squares — replace before any release.
+   Resource step depends on it). The icon set (`32x32.png`, `128x128.png`,
+   `128x128@2x.png`, `icon.ico`, `icon.icns`, the `Square*Logo`/`StoreLogo`
+   set) is generated from `apps/client/public/favicon.svg` via
+   `pnpm --filter @tarkov-checker/desktop exec tauri icon <path>/favicon.svg`
+   — the same mark the browser build uses. Re-run that after editing the SVG;
+   the generator also emits `ios/` + `android/` dirs which we delete (this is a
+   Windows-only desktop app). `icons/128x128.png` is also `include_bytes!`'d
+   into the binary by `src/notify.rs` for the toast icon — see item 8.
+
+8. **Toast notifications must register their own AppUserModelID.**
+   `tauri-plugin-notification` only stamps the toast's AUMID when the exe runs
+   from outside `target/{debug,release}` — but the portable .exe ships straight
+   out of `target/release` and dev runs from `target/debug`, so the plugin
+   always skips it and `notify-rust` falls back to PowerShell's identity (the
+   toast shows "PowerShell" + its icon). Fix: we don't use the plugin.
+   `src/notify.rs` registers `HKCU\Software\Classes\AppUserModelId\<identifier>`
+   with a `DisplayName` + `IconUri` (the favicon PNG, written to
+   `%APPDATA%/tarkov-checker/notification-icon.png`) at startup, then emits the
+   toast via `tauri-winrt-notification::Toast::new(<identifier>)`. No installer
+   / Start-Menu shortcut needed. Only used today for the one-time "still
+   running in the tray" hint (`commands::notify_tray_hint`, fired by the
+   client's `useCloseConfirm` gated on `tc.overlay.trayHintShown`).
 
 ## CI & releases
 
diff --git a/README.md b/README.md
index 316f18c..e9dd54f 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,7 @@ A live in-raid map companion for Escape from Tarkov. The overlay watches your Ta
 
 **Desktop overlay** (primary): a single 6 MB portable `.exe` that opens as a frameless transparent always-on-top window over your game. No installer, no admin rights, no background service. All game monitoring happens in-process — your position is extracted from Tarkov's PrintScreen overlay screenshots, and raid transitions are detected by parsing the active session logs.
 
-**LAN / phone PWA** (optional): a lightweight Node/Fastify server on your PC serves the same map interface to any browser on your local network — perfect for a second monitor or a phone on the same Wi-Fi.
+**LAN / phone PWA** (optional): the overlay's in-process Rust helper (axum, on `0.0.0.0:47474`) serves the same map interface to any browser on your local network — perfect for a second monitor or a phone on the same Wi-Fi. The release build serves the embedded SPA directly; in dev, Vite on :5173 proxies to it.
 
 ## Quick Start
 
@@ -30,7 +30,7 @@ A live in-raid map companion for Escape from Tarkov. The overlay watches your Ta
 3. Double-click to launch. On first run, the overlay auto-detects your Tarkov installation via the Windows registry. If that fails, manually set the paths in **Settings → Tarkov paths**.
 4. In Tarkov, press **PrintScreen** during a raid. The screenshot drops into your Tarkov screenshots folder, and the overlay reads its filename to update your position on the map.
 
-**Data storage**: settings and cache live in `%APPDATA%/tarkov-checker/`. Closing the window fully exits the app — nothing lingers in Task Manager.
+**Data storage**: settings and cache live in `%APPDATA%/tarkov-checker/`. By default, closing the window exits the app. Optionally, enable "Minimize to tray" in Settings to hide the window to the system tray instead of closing (the tray icon's "Show" restores it, "Quit" exits).
 
 ### Developers
 
@@ -70,7 +70,7 @@ If auto-detect fails, fill in **Game folder** in Settings and click **Save**. Wa
 
 ## Feature Details
 
-**Live player position**: The overlay monitors your Tarkov screenshots folder. Each PrintScreen you take in-raid embeds your world position (x, z coordinates) and viewing direction (quaternion) in the filename. The overlay parses this, places a directional arrow on the correct map at the correct rotation, and optionally auto-recenters and zooms to follow you (configurable: Off / Small / Medium / Large).
+**Live player position**: The overlay monitors your Tarkov screenshots folder. Each PrintScreen you take in-raid embeds your world position (x, z coordinates) and viewing direction (quaternion) in the filename. The overlay parses this, places a directional arrow on the correct map at the correct rotation, and optionally auto-recenters to follow you (toggle on/off in the Player section of Settings).
 
 **Auto-map switching**: The overlay tails your active Tarkov session log and detects scene-preset and Transit-location lines. When you load into a raid, it automatically flips the displayed map to match. This includes aliases for maps renamed in patch 1.0.5.0 (Factory, Reserve, Interchange). Toggle in Settings; enabled by default.
 
@@ -78,17 +78,19 @@ If auto-detect fails, fill in **Game folder** in Settings and click **Save**. Wa
 
 **Extracts overlay**: displays every known extract on every map with faction filtering (PMC / Scav / Shared) and label customization (always visible or on hover). Uses the same faction-color scheme across all UI elements.
 
-**Multi-floor maps**: Most maps have floor switchers (Customs, Factory, Shoreline, Reserve, Interchange, Streets, The Lab, Ground Zero). Woods and Lighthouse are single-level. Navigate with UI buttons or hotkeys to toggle between levels.
+**Multi-floor maps**: Most maps have floor switchers (Customs, Factory, Shoreline, Reserve, Interchange, Streets, The Lab, Ground Zero). Woods and Lighthouse are single-level. Switch floors via the stepper in the left-side layer rail, or hold **Alt** and scroll your mouse wheel over the map. Dedicated hotkeys (Floor-up/Floor-down) also work.
 
 **Window controls** (desktop overlay only):
 
 - **Drag** the transport-status pill in the top-right to move the overlay
-- **Click-through lock** (Ctrl+Alt+L) — toggle whether mouse clicks pass through to the game underneath
+- **Layer rail** (left edge of map) — quick toggles to show/hide player position, extracts, airdrop markers. Each layer has a gear icon to open its settings.
+- **Settings button** (gear in top-right cluster) — app/system preferences: overlay opacity, hotkeys, language, Tarkov paths, pairing. Layer settings are accessed via the rail.
+- **Click-through lock** (Ctrl+Alt+L) — toggle whether mouse clicks pass through to the game underneath. When locked, the interactive controls hide but glanceable readouts remain: Tarkov time, map name, connection status, floor indicator (top-left), and the unlock hotkey hint (bottom-right).
 - **Always-on-top** — keep the overlay above Tarkov even when the game window is focused
 - **Opacity slider** — adjust overall window transparency (30–100%). Map area and other UI elements fade uniformly.
-- **Map opacity slider** — independently adjust map transparency while keeping UI controls solid (0–100%, Tauri only)
+- **Map opacity slider** — independently adjust map transparency while keeping UI controls solid (0–100%)
 - **Zoom** — scale the entire UI
-- **Close** button with confirmation to prevent accidental exits
+- **Close** button with confirmation (unless "Minimize to tray" is enabled, then it hides to the tray)
 
 ## Supported Maps
 
@@ -98,7 +100,7 @@ Customs, Factory (Day/Night), Woods, Shoreline, Reserve, Interchange, Lighthouse
 
 The project consists of:
 
-- **Tauri 2 desktop wrapper** (`apps/desktop`) — native window management, file watchers, screenshot parser, log tailer, in-process HTTP server (Rust + axum) on `127.0.0.1:47474`, IPC bridge to the web UI
+- **Tauri 2 desktop wrapper** (`apps/desktop`) — native window management, file watchers, screenshot parser, log tailer, in-process HTTP server (Rust + axum) on `0.0.0.0:47474`, IPC bridge to the web UI
 - **Vue 3 + Leaflet map** (`apps/client`) — interactive map rendering, extract markers, player position arrow, UI controls; talks to the helper via Tauri IPC inside the overlay and via HTTP + SSE when opened in a regular browser
 - **Shared modules** (`packages/shared`) — map calibration data, position/event schemas, log parser, type definitions
 
@@ -106,7 +108,7 @@ Screenshots and logs are processed locally with no external API calls during gam
 
 ## Architecture Details
 
-See [CLAUDE.md](CLAUDE.md) for in-depth engineering documentation: dev workflow, Tauri overlay configuration, multi-version logs parsing, Windows build quirks, CI/release procedures, and the in-process Rust HTTP server (`/api/config`, `/events`).
+See [CLAUDE.md](CLAUDE.md) for in-depth engineering documentation: dev workflow, Tauri overlay configuration, multi-version logs parsing, Windows build quirks, CI/release procedures, and the in-process Rust HTTP server (`/api/config`, `/api/hotkeys`, `/events`).
 
 ## Credits
 
@@ -142,7 +144,7 @@ See [LICENSE](./LICENSE).
 
 **Десктоп-оверлей** (основной): один портативный `.exe` размером 6 МБ, открывающийся безрамочным прозрачным окном поверх игры. Без установщика, без админских прав, без фоновых сервисов. Все отслеживание игры происходит в одном процессе — ваша позиция извлекается из PrintScreen-скриншотов с оверлеем Tarkov, а переходы между рейдами определяются парсингом логов активной сессии.
 
-**LAN / PWA на телефоне** (опционально): легкий Node/Fastify-сервер на ПК отдаёт ту же карту в браузер любого устройства в локальной сети — идеально для второго монитора или телефона в одной Wi-Fi сети.
+**LAN / PWA на телефоне** (опционально): встроенный в оверлей Rust-хелпер (axum, на `0.0.0.0:47474`) отдаёт ту же карту в браузер любого устройства в локальной сети — идеально для второго монитора или телефона в одной Wi-Fi сети. Release-сборка отдаёт встроенный SPA напрямую; в режиме разработки Vite на :5173 проксирует к нему.
 
 ## Быстрый старт
 
@@ -153,7 +155,7 @@ See [LICENSE](./LICENSE).
 3. Запусти двойным кликом. При первом запуске оверлей автоматически обнаружит твою установку Tarkov через реестр Windows. Если не получится, вручную укажи пути в **Settings → Tarkov paths**.
 4. В Tarkov нажми **PrintScreen** во время рейда. Скриншот упадёт в папку скриншотов Tarkov, а оверлей прочитает имя файла и обновит твою позицию на карте.
 
-**Хранение данных**: настройки и кэш живут в `%APPDATA%/tarkov-checker/`. Закрытие окна полностью завершает приложение — ничего не остаётся в Диспетчере задач.
+**Хранение данных**: настройки и кэш живут в `%APPDATA%/tarkov-checker/`. По умолчанию закрытие окна завершает приложение. Опционально включи "Minimize to tray" в Settings, чтобы скрыть окно в системный трей вместо закрытия (пункт "Show" в меню трея его восстанавливает, "Quit" завершает приложение).
 
 ### Для разработчиков
 
@@ -193,7 +195,7 @@ pnpm --filter @tarkov-checker/desktop tauri:dev
 
 ## Подробное описание функций
 
-**Отслеживание позиции игрока**: оверлей мониторит папку скриншотов Tarkov. Каждый PrintScreen во время рейда содержит в имени файла твои мировые координаты (x, z) и направление взгляда (кватернион). Оверлей парсит это, ставит стрелку на правильную карту под правильным углом и опционально автоцентрирует и приближает вид, чтобы следить за тобой (настраивается: Выключено / Малый / Средний / Большой).
+**Отслеживание позиции игрока**: оверлей мониторит папку скриншотов Tarkov. Каждый PrintScreen во время рейда содержит в имени файла твои мировые координаты (x, z) и направление взгляда (кватернион). Оверлей парсит это, ставит стрелку на правильную карту под правильным углом и опционально автоцентрирует вид, чтобы следить за тобой (включается/выключается в разделе Player в Settings).
 
 **Автосмена карт**: оверлей отслеживает активный лог сессии Tarkov и ловит строки scene-preset и Transit-location. Когда ты загружаешься в рейд, отображаемая карта автоматически переключается. Это включает поддержку переименованных в патче 1.0.5.0 карт (Factory, Reserve, Interchange). Включается в Settings; по умолчанию включено.
 
@@ -201,17 +203,19 @@ pnpm --filter @tarkov-checker/desktop tauri:dev
 
 **Оверлей выходов**: отображает все известные выходы на каждой карте с фильтром по фракциям (PMC / Scav / Shared) и настройкой видимости подписей (всегда или при наведении). Использует одну цветовую схему фракций по всему интерфейсу.
 
-**Многоэтажные карты**: на большинстве карт есть переключатели этажей (Customs, Factory, Shoreline, Reserve, Interchange, Streets, The Lab, Ground Zero). Woods и Lighthouse одноуровневые. Навигируй кнопками UI или хоткеями между уровнями.
+**Многоэтажные карты**: на большинстве карт есть переключатели этажей (Customs, Factory, Shoreline, Reserve, Interchange, Streets, The Lab, Ground Zero). Woods и Lighthouse одноуровневые. Переключай этажи через степпер на левом rail-е карты, или зажми **Alt** и крутни колёсико мыши над картой. Работают и отдельные хоткеи (Floor-up/Floor-down).
 
 **Управление окном** (только десктоп-оверлей):
 
 - **Перетаскивание**: транспортный статус в правом верхнем углу — перетащи, чтобы переместить оверлей
-- **Блокировка клика** (Ctrl+Alt+L) — переключай, проходят ли клики мышки сквозь окно в игру
+- **Layer rail** (левый край карты) — быстрые переключатели для показа/скрытия позиции игрока, выходов, маркеров дропа. У каждого слоя есть иконка шестерёнки для его настроек.
+- **Кнопка Settings** (шестерёнка в правом верхнем кластере) — параметры приложения и системы: прозрачность оверлея, хоткеи, язык, пути Tarkov, pairing. Настройки слоёв открываются через rail.
+- **Блокировка клика** (Ctrl+Alt+L) — переключай, проходят ли клики мышки сквозь окно в игру. Когда заблокирован, интерактивные элементы скрываются, но видная информация остаётся: время Tarkov, имя карты, статус соединения, индикатор этажа (левый верхний угол) и подсказка по хоткею разблокировки (правый нижний угол).
 - **Поверх всех окон** — держи оверлей над Tarkov, даже когда окно игры в фокусе
 - **Ползунок прозрачности** — изменяй общую видимость окна (30–100%). Карта и весь интерфейс исчезают равномерно.
-- **Ползунок прозрачности карты** — независимо изменяй видимость карты, сохраняя UI элементы непрозрачными (0–100%, только Tauri)
+- **Ползунок прозрачности карты** — независимо изменяй видимость карты, сохраняя UI элементы непрозрачными (0–100%)
 - **Масштаб** — меняй размер всего интерфейса
-- **Кнопка закрытия** с подтверждением, чтобы не закрыть случайно
+- **Кнопка закрытия** с подтверждением (если не включена опция "Minimize to tray", тогда скрывает в трей)
 
 ## Поддерживаемые карты
 
@@ -221,7 +225,7 @@ Customs, Factory (День/Ночь), Woods, Shoreline, Reserve, Interchange, Li
 
 Проект состоит из:
 
-- **Tauri 2 десктоп-обёртка** (`apps/desktop`) — управление окнами, слежение за файлами, парсинг скриншотов, отслеживание логов, in-process HTTP-сервер (Rust + axum) на `127.0.0.1:47474`, IPC-мост к веб-интерфейсу
+- **Tauri 2 десктоп-обёртка** (`apps/desktop`) — управление окнами, слежение за файлами, парсинг скриншотов, отслеживание логов, in-process HTTP-сервер (Rust + axum) на `0.0.0.0:47474`, IPC-мост к веб-интерфейсу
 - **Vue 3 + Leaflet карта** (`apps/client`) — интерактивный рендеринг карты, маркеры выходов, стрелка позиции игрока, управление UI; внутри оверлея общается с хелпером через Tauri IPC, в обычном браузере — через HTTP + SSE
 - **Общие модули** (`packages/shared`) — калибровка карт, схемы позиций/событий, парсер логов, определения типов
 
@@ -229,7 +233,7 @@ Customs, Factory (День/Ночь), Woods, Shoreline, Reserve, Interchange, Li
 
 ## Архитектурные детали
 
-Смотри [CLAUDE.md](CLAUDE.md) для подробной инженерной документации: dev workflow, конфигурация Tauri-оверлея, парсинг многоверсионных логов, подводные камни Windows-сборки, процедуры CI/релиза, и in-process Rust HTTP-сервер (`/api/config`, `/events`).
+Смотри [CLAUDE.md](CLAUDE.md) для подробной инженерной документации: dev workflow, конфигурация Tauri-оверлея, парсинг многоверсионных логов, подводные камни Windows-сборки, процедуры CI/релиза, и in-process Rust HTTP-сервер (`/api/config`, `/api/hotkeys`, `/events`).
 
 ## Благодарности
 
diff --git a/apps/client/README.md b/apps/client/README.md
index f833f3e..646bd43 100644
--- a/apps/client/README.md
+++ b/apps/client/README.md
@@ -1,6 +1,6 @@
 # @tarkov-checker/client
 
-Vue + Leaflet map. Runs both inside the Tauri overlay (`apps/desktop`) and as a plain browser page on phones over LAN (the same prod build Fastify serves at `:3000/`). Same code path, different transport (Tauri events vs SSE / `EventSource`).
+Vue + Leaflet map. Runs both inside the Tauri overlay (`apps/desktop`) and as a plain browser page on phones over LAN (the same prod build the in-process Rust helper in `apps/desktop` serves at `:47474/`; dev uses Vite on `:5173`, which proxies `/api` + `/events` to the helper). Same code path, different transport (Tauri events vs SSE / `EventSource`).
 
 Specifics about Tauri internals, Windows build quirks, and dev workflow live in [the repo CLAUDE.md](../../CLAUDE.md). This README is for contributors working **inside the client**.
 
@@ -21,15 +21,15 @@ Specifics about Tauri internals, Windows build quirks, and dev workflow live in
 app/        Composition root — router config.
 pages/      File-based routes. Add a *.vue here → it becomes a route. typed-router.d.ts is regenerated on dev/build.
 features/   One folder per business feature, each fully owns its slice:
-  map/         Leaflet map framework (useLeafletMap, useFloorSwitcher), layers registry + built-in layers (extracts/player/airdrop), MapView component, static extracts dataset (data/extracts/<code>.json — one file per canonical map)
+  map/         Leaflet map framework (useLeafletMap, useLayerVisibility), layers registry + built-in layers (extracts/player/airdrop), MapView + LayerRail components, static extracts dataset (data/extracts/<code>.json — one file per canonical map)
   airdrop/     Airdrop triangulation state machine, screenshot tracker, settings section
   overlay/     Tauri overlay window controls, opacity/zoom/mapOpacity sync, tray icon, overlay-specific components
-  hotkeys/     Global shortcuts, HotkeyRecorder, accelerator parser
-  server/      SSE/HTTP transport, typed IPC contract, server event bus, /api/config client
+  hotkeys/     Backend-owned combos synced via thin store (fetch/PUT), HotkeyRecorder, accelerator parser; only the overlay lock stays client-registered
+  server/      SSE/HTTP transport, typed IPC contract, server event bus, /api/config + /api/hotkeys clients
   i18n/        createI18n instance, store (apiLang persisted), locales/<code>.json files
   settings/    Settings registry, SettingsPanel.vue, section sub-components
 shared/     Cross-feature utilities (persisted-store, config) — no business logic
-App.vue     Tiny: <RouterView/> + ConfirmDialog + MapQuickMenu + side effects (transport, tray, lock hotkey)
+App.vue     Tiny: <RouterView/> + ConfirmDialog + MapQuickMenu + side effects (transport, tray, lock hotkey, hotkeys sync — backend load + recorder suspend/resume bridge)
 main.ts     createApp → pinia + router + i18n + PrimeVue
 theme.ts    PrimeVue Aura preset override (primary = purple)
 styles.css  Tailwind imports, font-faces, dark mode token tweaks
@@ -86,15 +86,16 @@ For nested or dynamic routes (`/raids/[id]`), see [Vue Router file-based docs](h
 2. Inside the feature: `./X` and `../X` imports.
 3. Other features depend on yours via `@/features/<name>/<thing>`.
 4. If the feature has persisted user settings — create `store.ts` using [`persistedRef`](./src/shared/persisted-store.ts) from `@/shared/persisted-store`. Each setting gets its own key like `tc.<name>.<field>`.
-5. If the feature has its own settings UI:
+5. If the feature has its own SYSTEM/app settings UI (the gear drawer). Map-layer
+   settings live on the layer registration instead — see step 6.
    - Create a section component `XxxSection.vue` under [`features/settings/sections/`](./src/features/settings/sections/).
    - Create `src/features/<name>/settings.ts` that calls `registerSettingsSection()`:
      ```ts
      import { registerSettingsSection } from '@/features/settings/registry';
      registerSettingsSection({
        id: '<name>',
-       group: 'main', // or 'system'
        order: 30, // multiples of 10
+       titleKey: 'xxx.heading', // i18n key for the section title
        visible: 'always', // or 'tauri', 'desktop-or-tauri'
        component: XxxSection,
      });
@@ -102,7 +103,8 @@ For nested or dynamic routes (`/raids/[id]`), see [Vue Router file-based docs](h
    - That's it — `main.ts` auto-discovers the file via `import.meta.glob('@/features/*/settings.ts', { eager: true })`.
 6. If the feature adds a map layer (new extract/player marker/etc):
    - Create `src/features/map/layers/<name>/` with `useXxxLayer.ts` and `index.ts`.
-   - Call `registerMapLayer({ id, mount: useXxxLayer })` in `index.ts`.
+   - Call `registerMapLayer({ id, mount: useXxxLayer, category, order, titleKey, settingsComponent })` in `index.ts` — the rail category, order, display name, and optional inline settings component all live on the layer registration (no separate `settings.ts` for layers).
+   - Inside your composable, read `ctx.visible` (wired to the on-map LayerRail toggle via `useLayerVisibility(id)`) and `watch` it to add/remove your Leaflet root when toggled.
    - `main.ts` auto-discovers via `import.meta.glob('@/features/map/layers/*/index.ts', { eager: true })`.
 
 ### Add a new locale
@@ -182,15 +184,15 @@ pnpm lint       # eslint --max-warnings=0
 ## Where things connect
 
 - **Tauri detection** — centralized in [`shared/tauri.ts`](./src/shared/tauri.ts) as `isTauri` const. Checked at module load time, safe for non-DOM contexts. Used by transport layer, router, overlay composables, and settings visibility logic.
-- **Server-pushed messages** — schema in [`@shared/ws-messages`](../../packages/shared/src/ws-messages.ts). Position + map-change events; Node server pushes over SSE, Rust port emits as Tauri events. Client uses the same Zod schema either way.
+- **Server-pushed messages** — schema in [`@shared/sse-messages`](../../packages/shared/src/sse-messages.ts). Position, map-change, command (backend-owned hotkey press), and hotkeys (config re-sync after a rebind) events; the in-process Rust helper pushes over SSE to browsers, and emits as Tauri events to the overlay webview. Client uses the same Zod schema either way.
 - **Tarkov map calibration** (CRS, bounds, rotation) — [`@shared/maps`](../../packages/shared/src/maps.ts). Modifying calibration affects both desktop and browser.
 - **Map localization** — `useMapI18n()` composable in [`features/map/composables/useMapI18n.ts`](./src/features/map/composables/useMapI18n.ts) provides `localizedMapName(code)` with `te → t → displayName` fallback chain. Used in MapView + MapSection to stay in sync.
 - **HTTP / IPC** — single dispatch in [`features/server/api/transport.ts`](./src/features/server/api/transport.ts).
-- **Settings registry** — `registerSettingsSection()` in [`features/settings/registry.ts`](./src/features/settings/registry.ts). Each feature calls this at module load via `features/<name>/settings.ts`. Auto-discovered by `main.ts`.
-- **Map layers registry** — `registerMapLayer()` in [`features/map/layers/registry.ts`](./src/features/map/layers/registry.ts). Each layer calls this via `features/map/layers/<name>/index.ts`. Auto-discovered by `main.ts`; mounted by `MapView.vue` in setup().
+- **Settings registry** — `registerSettingsSection()` in [`features/settings/registry.ts`](./src/features/settings/registry.ts) — **system/app settings only** (gear-drawer accordion). Each feature calls it at module load via `features/<name>/settings.ts`. Map-LAYER settings live on the map-layer registration instead (below).
+- **Map layers registry** — `registerMapLayer()` in [`features/map/layers/registry.ts`](./src/features/map/layers/registry.ts) — the single source of truth for layers, carrying each layer's rail `category`/`order`/`titleKey`/`settingsComponent`. Each layer calls it via `features/map/layers/<name>/index.ts`; auto-discovered by `main.ts`, mounted by `MapView.vue`, rendered by the on-map `LayerRail`. Per-layer show/hide is `useLayerVisibility`; edge-indicator layers read the rail rect from `useRailObstacle`.
 
 ## See also
 
-- [`CLAUDE.md`](../../CLAUDE.md) — repo-wide context: Tauri internals, Windows build quirks (HVCI/Defender), path resolution dual implementation (Node + Rust), why ASCII-only repo path matters.
+- [`CLAUDE.md`](../../CLAUDE.md) — repo-wide context: Tauri internals, Windows build quirks (HVCI/Defender), Rust path resolution, why ASCII-only repo path matters.
 - [`apps/desktop/README.md`](../desktop/README.md) — Tauri overlay specifics.
-- [`packages/shared/`](../../packages/shared/) — Zod schemas + map calibration tables shared between client, Node server, and Rust port.
+- [`packages/shared/`](../../packages/shared/) — Zod schemas + map calibration tables shared between the client and the Rust helper.
diff --git a/apps/client/index.html b/apps/client/index.html
index bc4ef1e..5a97677 100644
--- a/apps/client/index.html
+++ b/apps/client/index.html
@@ -5,6 +5,14 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
     <meta name="theme-color" content="#0b0b0b" />
+    <!-- PWA: "Add to Home Screen" gives iPhone an app-like chrome-free view
+         (iOS has no Fullscreen API); Android Chrome installs as standalone. -->
+    <link rel="manifest" href="/manifest.webmanifest" />
+    <link rel="apple-touch-icon" href="/favicon.svg" />
+    <meta name="mobile-web-app-capable" content="yes" />
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+    <meta name="apple-mobile-web-app-title" content="tarkov-checker" />
     <title>tarkov-checker</title>
   </head>
   <body class="text-neutral-100">
diff --git a/apps/client/package.json b/apps/client/package.json
index 2da162d..30e68e9 100644
--- a/apps/client/package.json
+++ b/apps/client/package.json
@@ -11,7 +11,8 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "vue-tsc -b --noEmit",
-    "lint": "eslint src"
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix"
   },
   "dependencies": {
     "@primeuix/themes": "^2.0.3",
diff --git a/apps/client/public/manifest.webmanifest b/apps/client/public/manifest.webmanifest
new file mode 100644
index 0000000..0421aaa
--- /dev/null
+++ b/apps/client/public/manifest.webmanifest
@@ -0,0 +1,19 @@
+{
+  "name": "tarkov-checker",
+  "short_name": "tarkov-checker",
+  "description": "Live Escape from Tarkov map overlay — second-screen map for your phone.",
+  "start_url": "/",
+  "scope": "/",
+  "display": "standalone",
+  "orientation": "any",
+  "background_color": "#0b0b0b",
+  "theme_color": "#0b0b0b",
+  "icons": [
+    {
+      "src": "/favicon.svg",
+      "sizes": "any",
+      "type": "image/svg+xml",
+      "purpose": "any"
+    }
+  ]
+}
diff --git a/apps/client/src/App.vue b/apps/client/src/App.vue
index 5366711..e4abf15 100644
--- a/apps/client/src/App.vue
+++ b/apps/client/src/App.vue
@@ -1,16 +1,19 @@
 <script setup lang="ts">
 import MapQuickMenu from '@/features/overlay/components/MapQuickMenu.vue';
 import PairingModal from '@/features/overlay/components/PairingModal.vue';
+import UpdateBanner from '@/features/updater/components/UpdateBanner.vue';
 import { useServerTransport } from '@/features/server/composables/useServerTransport';
 import { provideTransportStatus } from '@/features/server/composables/useTransportStatus';
 import { useOverlayStore } from '@/features/overlay/store';
 import { useHotkeysStore } from '@/features/hotkeys/store';
 import { useTauriOverlay } from '@/features/overlay/composables/useTauriOverlay';
 import { useGlobalShortcut } from '@/features/hotkeys/composables/useGlobalShortcut';
+import { useHotkeysSync } from '@/features/hotkeys/composables/useHotkeysSync';
 import { useTrayIcon } from '@/features/overlay/composables/useTrayIcon';
 import { useOverlayBootstrap } from '@/features/overlay/composables/useOverlayBootstrap';
 import { useAutoMapSwitch } from '@/features/map/composables/useAutoMapSwitch';
 import { eventsUrl } from '@/shared/config';
+import { useConfirm } from 'primevue/useconfirm';
 
 const { clickThrough: overlayClickThrough } = storeToRefs(useOverlayStore());
 const { lockHotkey } = storeToRefs(useHotkeysStore());
@@ -26,17 +29,32 @@ provideTransportStatus(status);
 // regardless of which route is currently mounted.
 useAutoMapSwitch();
 
-// Lock toggle is the only truly global hotkey — every other map-specific
-// shortcut lives inside OverlayView, scoped to that route.
+// Lock toggle stays a client-side global shortcut: it's an overlay window op
+// (click-through) with no browser meaning, and keeping it on the proven plugin
+// path preserves the recovery route out of a click-through lockout. Every other
+// hotkey is backend-owned and arrives as a `command` event (see index.vue).
 useGlobalShortcut(isTauri, lockHotkey, () => {
   overlayClickThrough.value = !overlayClickThrough.value;
 });
 
+// Load backend-owned combos into the store + bridge the recorder's
+// suspend/resume to the backend (so a combo can be re-recorded).
+useHotkeysSync();
+
 useOverlayBootstrap(overlayClickThrough);
 useTrayIcon(isTauri, overlayClickThrough);
 
+const confirm = useConfirm();
 const quickMenu = ref<InstanceType<typeof MapQuickMenu> | null>(null);
 
+// Close transient UI when the overlay locks so click-through can't strand them.
+watch(overlayClickThrough, (locked) => {
+  if (locked) {
+    confirm.close();
+    quickMenu.value?.close();
+  }
+});
+
 // Right-click anywhere over the Leaflet canvas opens the transparency panel.
 // Lives at the app root so the same gesture works regardless of which route
 // is mounted underneath.
@@ -59,8 +77,11 @@ function onMapContextMenu(event: MouseEvent): void {
     mount it at all there.
   -->
   <PairingModal v-if="isTauri" />
+  <!-- Self-update is a Tauri-only concern: browsers/phones always load the
+       SPA the helper serves, they have nothing to update themselves. -->
+  <UpdateBanner v-if="isTauri" />
   <div
-    class="relative h-screen w-screen text-surface-0"
+    class="relative h-full w-screen text-surface-0"
     :class="isTauri ? '' : 'bg-surface-950'"
     @contextmenu="onMapContextMenu"
   >
diff --git a/apps/client/src/__tests__/hotkey.spec.ts b/apps/client/src/__tests__/hotkey.spec.ts
new file mode 100644
index 0000000..5dd040b
--- /dev/null
+++ b/apps/client/src/__tests__/hotkey.spec.ts
@@ -0,0 +1,246 @@
+import { describe, it, expect } from 'vitest';
+import { captureHotkey, formatHotkeyParts } from '@/features/hotkeys/lib/hotkey';
+
+// Mirror of the keys accepted by global-hotkey 0.7.0's `parse_key` (uppercased
+// before matching). Our captured main-key tokens MUST land in this set or
+// Tauri's register() throws and the binding silently reverts (the Num- bug).
+const CRATE_ACCEPTED = new Set<string>([
+  ...'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split(''),
+  ...'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('').map((l) => `KEY${l}`),
+  ...'0123456789'.split(''),
+  ...'0123456789'.split('').map((d) => `DIGIT${d}`),
+  'BACKQUOTE',
+  '`',
+  'BACKSLASH',
+  '\\',
+  'BRACKETLEFT',
+  '[',
+  'BRACKETRIGHT',
+  ']',
+  'COMMA',
+  ',',
+  'EQUAL',
+  '=',
+  'MINUS',
+  '-',
+  'PERIOD',
+  '.',
+  'QUOTE',
+  "'",
+  'SEMICOLON',
+  ';',
+  'SLASH',
+  '/',
+  'SPACE',
+  'TAB',
+  'ENTER',
+  'BACKSPACE',
+  'DELETE',
+  'END',
+  'HOME',
+  'INSERT',
+  'PAGEDOWN',
+  'PAGEUP',
+  'ARROWDOWN',
+  'DOWN',
+  'ARROWLEFT',
+  'LEFT',
+  'ARROWRIGHT',
+  'RIGHT',
+  'ARROWUP',
+  'UP',
+  'NUMPAD0',
+  'NUM0',
+  'NUMPAD1',
+  'NUM1',
+  'NUMPAD2',
+  'NUM2',
+  'NUMPAD3',
+  'NUM3',
+  'NUMPAD4',
+  'NUM4',
+  'NUMPAD5',
+  'NUM5',
+  'NUMPAD6',
+  'NUM6',
+  'NUMPAD7',
+  'NUM7',
+  'NUMPAD8',
+  'NUM8',
+  'NUMPAD9',
+  'NUM9',
+  'NUMPADADD',
+  'NUMADD',
+  'NUMPADPLUS',
+  'NUMPLUS',
+  'NUMPADSUBTRACT',
+  'NUMSUBTRACT',
+  'NUMPADMULTIPLY',
+  'NUMMULTIPLY',
+  'NUMPADDIVIDE',
+  'NUMDIVIDE',
+  'NUMPADDECIMAL',
+  'NUMDECIMAL',
+  'NUMPADENTER',
+  'NUMENTER',
+  'NUMPADEQUAL',
+  'NUMEQUAL',
+  ...Array.from({ length: 24 }, (_, i) => `F${i + 1}`),
+]);
+
+interface Mods {
+  ctrl?: boolean;
+  alt?: boolean;
+  shift?: boolean;
+  meta?: boolean;
+  altGraph?: boolean;
+}
+
+function ev(code: string, mods: Mods = {}, key = ''): KeyboardEvent {
+  return new KeyboardEvent('keydown', {
+    code,
+    key,
+    ctrlKey: !!mods.ctrl,
+    altKey: !!mods.alt,
+    shiftKey: !!mods.shift,
+    metaKey: !!mods.meta,
+    modifierAltGraph: !!mods.altGraph,
+  });
+}
+
+/** Last token of an accelerator string (the main key). */
+function mainKey(combo: string): string {
+  const parts = combo.split('+');
+  return parts[parts.length - 1] ?? '';
+}
+
+describe('captureHotkey — main keys', () => {
+  it('letters map KeyX → X', () => {
+    expect(captureHotkey(ev('KeyL', { ctrl: true, alt: true })).combo).toBe(
+      'CommandOrControl+Alt+L',
+    );
+  });
+
+  it('digits map DigitN → N', () => {
+    expect(captureHotkey(ev('Digit5', { ctrl: true })).combo).toBe('CommandOrControl+5');
+  });
+
+  it('function keys pass through', () => {
+    expect(captureHotkey(ev('F7', { alt: true })).combo).toBe('Alt+F7');
+  });
+
+  it('main-row minus is "-"', () => {
+    expect(captureHotkey(ev('Minus', { ctrl: true })).combo).toBe('CommandOrControl+-');
+  });
+
+  it('meta counts as CommandOrControl', () => {
+    expect(captureHotkey(ev('KeyK', { meta: true })).combo).toBe('CommandOrControl+K');
+  });
+});
+
+describe('captureHotkey — numpad (regression for the Num- bug)', () => {
+  const NUMPAD_CODES = [
+    'Numpad0',
+    'Numpad1',
+    'Numpad2',
+    'Numpad3',
+    'Numpad4',
+    'Numpad5',
+    'Numpad6',
+    'Numpad7',
+    'Numpad8',
+    'Numpad9',
+    'NumpadAdd',
+    'NumpadSubtract',
+    'NumpadMultiply',
+    'NumpadDivide',
+    'NumpadDecimal',
+    'NumpadEnter',
+  ];
+
+  it('NumpadSubtract no longer collapses to "-"', () => {
+    const combo = captureHotkey(ev('NumpadSubtract', { ctrl: true })).combo;
+    expect(combo).toBe('CommandOrControl+NumpadSubtract');
+    expect(mainKey(combo!)).not.toBe('-');
+  });
+
+  it('NumpadAdd keeps working', () => {
+    expect(captureHotkey(ev('NumpadAdd', { ctrl: true })).combo).toBe('CommandOrControl+NumpadAdd');
+  });
+
+  it('every numpad token is accepted by the global-hotkey parser', () => {
+    for (const code of NUMPAD_CODES) {
+      const combo = captureHotkey(ev(code, { ctrl: true })).combo;
+      expect(combo, `no combo for ${code}`).toBeTruthy();
+      const token = mainKey(combo!).toUpperCase();
+      expect(CRATE_ACCEPTED.has(token), `${code} → "${token}" rejected by crate`).toBe(true);
+    }
+  });
+});
+
+describe('captureHotkey — validation', () => {
+  it('requires a modifier', () => {
+    const r = captureHotkey(ev('KeyL'));
+    expect(r.combo).toBeNull();
+    expect(r.error).toBe('no-modifier');
+  });
+
+  it('Escape cancels recording', () => {
+    const r = captureHotkey(ev('Escape', { ctrl: true }, 'Escape'));
+    expect(r.cancelled).toBe(true);
+  });
+
+  it('holding only modifiers waits for a main key', () => {
+    const r = captureHotkey(ev('ControlLeft', { ctrl: true }, 'Control'));
+    expect(r.combo).toBeNull();
+    expect(r.error).toBeNull();
+  });
+
+  it('right Alt as AltGr is rejected (too layout-unstable to bind)', () => {
+    const r = captureHotkey(ev('AltRight', { altGraph: true }, 'AltGraph'));
+    expect(r.combo).toBeNull();
+    expect(r.error).toBe('altgr');
+  });
+
+  it('right Alt as plain Alt (e.g. EN layout) waits', () => {
+    const r = captureHotkey(ev('AltRight', { alt: true }, 'Alt'));
+    expect(r.combo).toBeNull();
+    expect(r.error).toBeNull();
+  });
+
+  it('right-modifier codes are never main keys', () => {
+    for (const code of ['ShiftRight', 'ControlRight', 'MetaRight']) {
+      expect(captureHotkey(ev(code, { shift: true })).error).toBeNull();
+    }
+  });
+
+  it('AltGr + key is rejected, but a genuine Ctrl+Alt is not', () => {
+    // AltGr (right Alt on RU) sets the AltGraph modifier → rejected.
+    const altgr = captureHotkey(ev('KeyZ', { altGraph: true, ctrl: true }));
+    expect(altgr.combo).toBeNull();
+    expect(altgr.error).toBe('altgr');
+    // Manual Ctrl+Alt does NOT set AltGraph → still bindable.
+    expect(captureHotkey(ev('KeyZ', { ctrl: true, alt: true })).combo).toBe(
+      'CommandOrControl+Alt+Z',
+    );
+  });
+
+  it('unmapped keys are rejected', () => {
+    const r = captureHotkey(ev('MediaSelect', { ctrl: true }));
+    expect(r.error).toBe('bad-main-key');
+  });
+});
+
+describe('formatHotkeyParts', () => {
+  it('renders canonical numpad tokens', () => {
+    expect(formatHotkeyParts('CommandOrControl+NumpadSubtract')).toEqual(['Ctrl', 'Num -']);
+  });
+
+  it('still renders legacy persisted tokens', () => {
+    expect(formatHotkeyParts('CommandOrControl+numadd')).toEqual(['Ctrl', 'Num +']);
+  });
+
+  it('uppercases unknown main keys', () => {
+    expect(formatHotkeyParts('Alt+F7')).toEqual(['Alt', 'F7']);
+  });
+});
diff --git a/apps/client/src/__tests__/hotkeys-store.spec.ts b/apps/client/src/__tests__/hotkeys-store.spec.ts
new file mode 100644
index 0000000..90ed9f7
--- /dev/null
+++ b/apps/client/src/__tests__/hotkeys-store.spec.ts
@@ -0,0 +1,93 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { createPinia, setActivePinia } from 'pinia';
+import type { HotkeyConfig } from '@shared/hotkeys-api';
+
+// Mock the transport layer the store syncs through. Hoisted so the vi.mock
+// factory can reference the fns.
+const { fetchHotkeysMock, putHotkeysMock } = vi.hoisted(() => ({
+  fetchHotkeysMock: vi.fn(),
+  putHotkeysMock: vi.fn(),
+}));
+
+vi.mock('@/features/server/api/hotkeys-api', () => ({
+  fetchHotkeys: fetchHotkeysMock,
+  putHotkeys: putHotkeysMock,
+  suspendHotkeys: vi.fn(),
+  resumeHotkeys: vi.fn(),
+}));
+
+import { useHotkeysStore } from '@/features/hotkeys/store';
+
+const DEFAULTS: HotkeyConfig = {
+  zoomIn: 'CommandOrControl+=',
+  zoomOut: 'CommandOrControl+-',
+  floorUp: 'CommandOrControl+Shift+=',
+  floorDown: 'CommandOrControl+Shift+-',
+  airdrop: 'CommandOrControl+Alt+D',
+};
+
+beforeEach(() => {
+  setActivePinia(createPinia());
+  localStorage.clear();
+  fetchHotkeysMock.mockReset();
+  putHotkeysMock.mockReset();
+});
+
+describe('useHotkeysStore — backend sync', () => {
+  it('starts at defaults before load()', () => {
+    const store = useHotkeysStore();
+    expect(store.zoomInHotkey).toBe(DEFAULTS.zoomIn);
+    expect(store.airdropHotkey).toBe(DEFAULTS.airdrop);
+  });
+
+  it('load() applies the backend config', async () => {
+    fetchHotkeysMock.mockResolvedValue({ ...DEFAULTS, zoomIn: 'CommandOrControl+Alt+Z' });
+    const store = useHotkeysStore();
+    await store.load();
+    expect(store.zoomInHotkey).toBe('CommandOrControl+Alt+Z');
+  });
+
+  it('setAction PUTs and applies the effective response', async () => {
+    fetchHotkeysMock.mockResolvedValue(DEFAULTS);
+    putHotkeysMock.mockResolvedValue({ ...DEFAULTS, airdrop: 'CommandOrControl+Alt+X' });
+    const store = useHotkeysStore();
+    await store.load();
+
+    await store.setAction('airdrop', 'CommandOrControl+Alt+X');
+    expect(putHotkeysMock).toHaveBeenCalledWith({ airdrop: 'CommandOrControl+Alt+X' });
+    expect(store.airdropHotkey).toBe('CommandOrControl+Alt+X');
+  });
+
+  it('setAction reverts the optimistic value when the PUT rejects', async () => {
+    fetchHotkeysMock.mockResolvedValue(DEFAULTS);
+    putHotkeysMock.mockRejectedValue(new Error('HTTP 400'));
+    const store = useHotkeysStore();
+    await store.load();
+
+    await store.setAction('zoomIn', 'CommandOrControl+Alt+Q');
+    expect(store.zoomInHotkey).toBe(DEFAULTS.zoomIn); // reverted
+  });
+
+  it('migrates a customised legacy localStorage combo once', async () => {
+    // Old per-field persistedRef stored JSON-encoded strings.
+    localStorage.setItem('tc.hotkeys.zoomIn', JSON.stringify('CommandOrControl+Alt+M'));
+    fetchHotkeysMock.mockResolvedValue(DEFAULTS);
+    putHotkeysMock.mockResolvedValue({ ...DEFAULTS, zoomIn: 'CommandOrControl+Alt+M' });
+
+    const store = useHotkeysStore();
+    await store.load();
+
+    expect(putHotkeysMock).toHaveBeenCalledWith({ zoomIn: 'CommandOrControl+Alt+M' });
+    expect(store.zoomInHotkey).toBe('CommandOrControl+Alt+M');
+  });
+
+  it('does not migrate when legacy values equal the backend defaults', async () => {
+    localStorage.setItem('tc.hotkeys.zoomIn', JSON.stringify(DEFAULTS.zoomIn));
+    fetchHotkeysMock.mockResolvedValue(DEFAULTS);
+
+    const store = useHotkeysStore();
+    await store.load();
+
+    expect(putHotkeysMock).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/client/src/__tests__/map-layer-registry.spec.ts b/apps/client/src/__tests__/map-layer-registry.spec.ts
new file mode 100644
index 0000000..70db373
--- /dev/null
+++ b/apps/client/src/__tests__/map-layer-registry.spec.ts
@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import { registerMapLayer, useMapLayers } from '@/features/map/layers/registry';
+
+const noop = (): void => {};
+
+describe('map layer registry', () => {
+  it('registers a layer and exposes it via useMapLayers', () => {
+    registerMapLayer({ id: 'test-reg', mount: noop, category: 'loot', order: 99, titleKey: 'x' });
+    const found = useMapLayers().value.find((l) => l.id === 'test-reg');
+    expect(found?.category).toBe('loot');
+    expect(found?.order).toBe(99);
+  });
+
+  it('replaces by id on re-register (HMR-safe), never duplicating', () => {
+    registerMapLayer({ id: 'test-dup', mount: noop, category: 'player', order: 1, titleKey: 'a' });
+    registerMapLayer({ id: 'test-dup', mount: noop, category: 'quests', order: 2, titleKey: 'b' });
+    const matches = useMapLayers().value.filter((l) => l.id === 'test-dup');
+    expect(matches).toHaveLength(1);
+    expect(matches[0]?.category).toBe('quests');
+  });
+});
diff --git a/apps/client/src/__tests__/tarkov-time.spec.ts b/apps/client/src/__tests__/tarkov-time.spec.ts
new file mode 100644
index 0000000..cbab8dd
--- /dev/null
+++ b/apps/client/src/__tests__/tarkov-time.spec.ts
@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { tarkovTime } from '@shared/tarkov-time';
+
+const HOUR = 60 * 60 * 1000;
+
+describe('tarkovTime', () => {
+  it('at epoch is Moscow midnight + 3h (left) / +15h (right)', () => {
+    expect(tarkovTime(0)).toEqual({ left: '03:00', right: '15:00', seconds: '00' });
+  });
+
+  it('advances 7× real time', () => {
+    // 1 real hour → 7 in-game hours.
+    expect(tarkovTime(1 * HOUR)).toEqual({ left: '10:00', right: '22:00', seconds: '00' });
+  });
+
+  it('wraps past midnight', () => {
+    // 3 real hours → 21 in-game hours; 03:00 + 21h = 00:00.
+    expect(tarkovTime(3 * HOUR)).toEqual({ left: '00:00', right: '12:00', seconds: '00' });
+  });
+
+  it('the two clocks are always exactly 12h apart', () => {
+    for (const ms of [0, HOUR, 1_700_000_000_000, 1_234_567_890]) {
+      const { left, right } = tarkovTime(ms);
+      const toMin = (s: string) => {
+        const [h, m] = s.split(':').map(Number);
+        return (h ?? 0) * 60 + (m ?? 0);
+      };
+      const diff = (((toMin(right) - toMin(left)) % (24 * 60)) + 24 * 60) % (24 * 60);
+      expect(diff).toBe(12 * 60);
+    }
+  });
+});
diff --git a/apps/client/src/__tests__/useFloorSwitcher.spec.ts b/apps/client/src/__tests__/useFloorSwitcher.spec.ts
new file mode 100644
index 0000000..31a2393
--- /dev/null
+++ b/apps/client/src/__tests__/useFloorSwitcher.spec.ts
@@ -0,0 +1,53 @@
+import { describe, it, expect } from 'vitest';
+import { shallowRef } from 'vue';
+import { useFloorSwitcher, type LoadedMap } from '@/features/map/composables/useFloorSwitcher';
+
+// Floors are ordered top-to-bottom (index 0 = highest floor).
+const FLOORS = [{ id: '2' }, { id: '1' }, { id: '0' }, { id: '-1' }];
+
+// loaded = null: no SVG, so setActiveFloor just records the choice in
+// currentFloor (the DOM toggle path is skipped) — perfect for testing the
+// stepping logic in isolation.
+function make(floors = FLOORS, defaultFloor = '0') {
+  return useFloorSwitcher(shallowRef<LoadedMap | null>(null), floors, defaultFloor);
+}
+
+describe('useFloorSwitcher', () => {
+  it('floorUp goes to a higher floor, floorDown to a lower one', () => {
+    const f = make();
+    f.setActiveFloor('0');
+    f.floorUp();
+    expect(f.currentFloor.value).toBe('1');
+    f.floorUp();
+    expect(f.currentFloor.value).toBe('2');
+    f.floorDown();
+    expect(f.currentFloor.value).toBe('1');
+  });
+
+  it('clamps at the top floor (no wrap-around)', () => {
+    const f = make();
+    f.setActiveFloor('2');
+    f.floorUp();
+    expect(f.currentFloor.value).toBe('2');
+  });
+
+  it('clamps at the bottom floor (no wrap-around)', () => {
+    const f = make();
+    f.setActiveFloor('-1');
+    f.floorDown();
+    expect(f.currentFloor.value).toBe('-1');
+  });
+
+  it('starts from the default floor when none is active yet', () => {
+    const f = make();
+    f.floorUp();
+    expect(f.currentFloor.value).toBe('1');
+  });
+
+  it('is a no-op on single-floor maps', () => {
+    const f = make([{ id: 'only' }], 'only');
+    f.floorUp();
+    f.floorDown();
+    expect(f.currentFloor.value).toBeNull();
+  });
+});
diff --git a/apps/client/src/__tests__/useLayerVisibility.spec.ts b/apps/client/src/__tests__/useLayerVisibility.spec.ts
new file mode 100644
index 0000000..9829cd7
--- /dev/null
+++ b/apps/client/src/__tests__/useLayerVisibility.spec.ts
@@ -0,0 +1,30 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { nextTick } from 'vue';
+import { useLayerVisibility } from '@/features/map/composables/useLayerVisibility';
+
+// Each test uses a distinct id — the composable caches refs in a module-level
+// singleton that outlives a single test (by design: the persist watch must
+// survive component remounts).
+describe('useLayerVisibility', () => {
+  beforeEach(() => localStorage.clear());
+
+  it('defaults a fresh layer to visible', () => {
+    expect(useLayerVisibility('test-default').value).toBe(true);
+  });
+
+  it('returns the same ref for the same id (singleton)', () => {
+    expect(useLayerVisibility('test-singleton')).toBe(useLayerVisibility('test-singleton'));
+  });
+
+  it('persists a toggle to tc.layer.<id>.visible', async () => {
+    const v = useLayerVisibility('test-persist');
+    v.value = false;
+    await nextTick();
+    expect(localStorage.getItem('tc.layer.test-persist.visible')).toBe('false');
+  });
+
+  it('reads an existing persisted value on first use', () => {
+    localStorage.setItem('tc.layer.test-seeded.visible', 'false');
+    expect(useLayerVisibility('test-seeded').value).toBe(false);
+  });
+});
diff --git a/apps/client/src/__tests__/useServerTransport.spec.ts b/apps/client/src/__tests__/useServerTransport.spec.ts
index 63c27d9..0d017ec 100644
--- a/apps/client/src/__tests__/useServerTransport.spec.ts
+++ b/apps/client/src/__tests__/useServerTransport.spec.ts
@@ -88,19 +88,21 @@ describe('useServerTransport — Tauri path', () => {
     mockIsTauri = true;
   });
 
-  it('subscribes to "position" and "map-change" and flips status to open', async () => {
-    const off1 = vi.fn();
-    const off2 = vi.fn();
-    listenMock.mockResolvedValueOnce(off1).mockResolvedValueOnce(off2);
+  it('subscribes to "position", "map-change" and "command" and flips status to open', async () => {
+    listenMock
+      .mockResolvedValueOnce(vi.fn())
+      .mockResolvedValueOnce(vi.fn())
+      .mockResolvedValueOnce(vi.fn());
 
     const { result } = mountTransport('/events');
     expect(result.status.value).toBe('connecting');
 
     await flushMounted();
 
-    expect(listenMock).toHaveBeenCalledTimes(2);
+    expect(listenMock).toHaveBeenCalledTimes(3);
     expect(listenMock.mock.calls[0]![0]).toBe('position');
     expect(listenMock.mock.calls[1]![0]).toBe('map-change');
+    expect(listenMock.mock.calls[2]![0]).toBe('command');
     expect(result.status.value).toBe('open');
     expect(useServerStreamMock).not.toHaveBeenCalled();
   });
@@ -158,10 +160,33 @@ describe('useServerTransport — Tauri path', () => {
     expect(dispatchServerEventMock).not.toHaveBeenCalled();
   });
 
+  it('validates command payloads and dispatches them', async () => {
+    listenMock.mockResolvedValueOnce(vi.fn()); // position
+    listenMock.mockResolvedValueOnce(vi.fn()); // map-change
+    let commandHandler: ((event: { payload: unknown }) => void) | null = null;
+    listenMock.mockImplementationOnce(async (_name: string, handler) => {
+      commandHandler = handler;
+      return vi.fn();
+    });
+
+    mountTransport('/events');
+    await flushMounted();
+
+    expect(commandHandler).not.toBeNull();
+
+    commandHandler!({ payload: { action: 'zoom-in' } });
+    expect(dispatchServerEventMock).toHaveBeenCalledWith({ type: 'command', action: 'zoom-in' });
+
+    dispatchServerEventMock.mockClear();
+    commandHandler!({ payload: { action: 'not-an-action' } }); // bad enum value
+    expect(dispatchServerEventMock).not.toHaveBeenCalled();
+  });
+
   it('calls every unlisten and flips status to closed on unmount', async () => {
     const off1 = vi.fn();
     const off2 = vi.fn();
-    listenMock.mockResolvedValueOnce(off1).mockResolvedValueOnce(off2);
+    const off3 = vi.fn();
+    listenMock.mockResolvedValueOnce(off1).mockResolvedValueOnce(off2).mockResolvedValueOnce(off3);
 
     const { result, app } = mountTransport('/events');
     await flushMounted();
@@ -171,6 +196,7 @@ describe('useServerTransport — Tauri path', () => {
 
     expect(off1).toHaveBeenCalledTimes(1);
     expect(off2).toHaveBeenCalledTimes(1);
+    expect(off3).toHaveBeenCalledTimes(1);
     expect(result.status.value).toBe('closed');
   });
 });
diff --git a/apps/client/src/components.d.ts b/apps/client/src/components.d.ts
index 3496969..362cd28 100644
--- a/apps/client/src/components.d.ts
+++ b/apps/client/src/components.d.ts
@@ -11,21 +11,27 @@ export {}
 /* prettier-ignore */
 declare module 'vue' {
   export interface GlobalComponents {
+    Accordion: typeof import('primevue/accordion')['default']
+    AccordionContent: typeof import('primevue/accordioncontent')['default']
+    AccordionHeader: typeof import('primevue/accordionheader')['default']
+    AccordionPanel: typeof import('primevue/accordionpanel')['default']
     Button: typeof import('primevue/button')['default']
     Checkbox: typeof import('primevue/checkbox')['default']
     ConfirmDialog: typeof import('primevue/confirmdialog')['default']
     Dialog: typeof import('primevue/dialog')['default']
     Drawer: typeof import('primevue/drawer')['default']
-    Fieldset: typeof import('primevue/fieldset')['default']
     IconField: typeof import('primevue/iconfield')['default']
     InputIcon: typeof import('primevue/inputicon')['default']
     InputText: typeof import('primevue/inputtext')['default']
+    Listbox: typeof import('primevue/listbox')['default']
     Message: typeof import('primevue/message')['default']
     RouterLink: typeof import('vue-router')['RouterLink']
     RouterView: typeof import('vue-router')['RouterView']
-    Select: typeof import('primevue/select')['default']
     SelectButton: typeof import('primevue/selectbutton')['default']
     Slider: typeof import('primevue/slider')['default']
     ToggleSwitch: typeof import('primevue/toggleswitch')['default']
   }
+  export interface GlobalDirectives {
+    Tooltip: typeof import('primevue/tooltip')['default']
+  }
 }
diff --git a/apps/client/src/features/airdrop/settings.ts b/apps/client/src/features/airdrop/settings.ts
deleted file mode 100644
index 2b7ca05..0000000
--- a/apps/client/src/features/airdrop/settings.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { registerSettingsSection } from '@/features/settings/registry';
-import AirdropSection from '@/features/settings/sections/AirdropSection.vue';
-
-registerSettingsSection({
-  id: 'airdrop',
-  group: 'main',
-  order: 40,
-  visible: 'tauri',
-  component: AirdropSection,
-});
diff --git a/apps/client/src/features/display/components/DisplaySection.vue b/apps/client/src/features/display/components/DisplaySection.vue
new file mode 100644
index 0000000..660153b
--- /dev/null
+++ b/apps/client/src/features/display/components/DisplaySection.vue
@@ -0,0 +1,38 @@
+<script setup lang="ts">
+import { useDisplayEnv } from '../composables/useDisplayEnv';
+import { useFullscreenToggle } from '../composables/useFullscreenToggle';
+
+const { t } = useI18n();
+const { isIos, isStandalone } = useDisplayEnv();
+const { isFullscreen, isSupported: fsSupported, toggle: toggleFullscreen } = useFullscreenToggle();
+
+// Hide the fullscreen row once installed as a PWA (already chrome-free).
+const showFullscreenRow = computed(() => !isStandalone.value);
+const fullscreenToggleable = computed(() => fsSupported.value && !isIos);
+
+// ToggleSwitch bound to live fullscreen state — set just toggles, the getter
+// reflects the real state once `fullscreenchange` fires (no desync flash).
+const fullscreenModel = computed({
+  get: () => isFullscreen.value,
+  set: () => {
+    void toggleFullscreen().catch(() => undefined);
+  },
+});
+</script>
+
+<template>
+  <div v-if="showFullscreenRow" class="space-y-3">
+    <div class="flex items-center justify-between gap-3">
+      <label class="text-sm" for="display-fullscreen">{{ t('display.fullscreen') }}</label>
+      <ToggleSwitch
+        v-if="fullscreenToggleable"
+        v-model="fullscreenModel"
+        input-id="display-fullscreen"
+      />
+      <span v-else class="text-xs opacity-50">{{ t('display.fullscreenNA') }}</span>
+    </div>
+    <p v-if="!fullscreenToggleable && isIos" class="text-[10px] leading-relaxed opacity-70">
+      {{ t('display.iosHint') }}
+    </p>
+  </div>
+</template>
diff --git a/apps/client/src/features/display/composables/useDisplayEnv.ts b/apps/client/src/features/display/composables/useDisplayEnv.ts
new file mode 100644
index 0000000..8e24f82
--- /dev/null
+++ b/apps/client/src/features/display/composables/useDisplayEnv.ts
@@ -0,0 +1,30 @@
+import type { ComputedRef } from 'vue';
+
+// iOS (incl. iPadOS, which reports as Mac). Used only to pick the "Add to Home
+// Screen" hint when the Fullscreen API is absent — capability is otherwise gated
+// on real feature detection, never on this UA sniff.
+function isIosDevice(): boolean {
+  if (typeof navigator === 'undefined') return false;
+  const ua = navigator.userAgent;
+  return /iPhone|iPod|iPad/.test(ua) || (/Macintosh/.test(ua) && navigator.maxTouchPoints > 1);
+}
+
+function detectNavigatorStandalone(): boolean {
+  if (typeof navigator === 'undefined') return false;
+  return (navigator as Navigator & { standalone?: boolean }).standalone === true;
+}
+
+export interface DisplayEnv {
+  isIos: boolean;
+  /** Launched as an installed PWA (no browser chrome → fullscreen affordance moot). */
+  isStandalone: ComputedRef<boolean>;
+}
+
+export function useDisplayEnv(): DisplayEnv {
+  const displayModeStandalone = useMediaQuery('(display-mode: standalone)');
+  const navStandalone = detectNavigatorStandalone();
+  return {
+    isIos: isIosDevice(),
+    isStandalone: computed(() => displayModeStandalone.value || navStandalone),
+  };
+}
diff --git a/apps/client/src/features/display/composables/useFullscreenToggle.ts b/apps/client/src/features/display/composables/useFullscreenToggle.ts
new file mode 100644
index 0000000..a859066
--- /dev/null
+++ b/apps/client/src/features/display/composables/useFullscreenToggle.ts
@@ -0,0 +1,9 @@
+// Thin wrapper over VueUse useFullscreen. Targets documentElement so the
+// browser address bar collapses (not just an element). Callers get independent
+// instances that stay in sync via their own `fullscreenchange` listeners — no
+// shared singleton, so an unmounting consumer can't strand the others.
+export function useFullscreenToggle() {
+  const target = typeof document !== 'undefined' ? document.documentElement : undefined;
+  const { isFullscreen, isSupported, toggle } = useFullscreen(target);
+  return { isFullscreen, isSupported, toggle };
+}
diff --git a/apps/client/src/features/display/settings.ts b/apps/client/src/features/display/settings.ts
new file mode 100644
index 0000000..db0ec88
--- /dev/null
+++ b/apps/client/src/features/display/settings.ts
@@ -0,0 +1,12 @@
+import { registerSettingsSection } from '@/features/settings/registry';
+import DisplaySection from './components/DisplaySection.vue';
+
+// Browser/phone-only display prefs (fullscreen, keep-awake). Meaningless in the
+// frameless Tauri overlay, so gated to non-Tauri via the 'browser' visibility.
+registerSettingsSection({
+  id: 'display',
+  order: 25,
+  visible: 'browser',
+  titleKey: 'display.heading',
+  component: DisplaySection,
+});
diff --git a/apps/client/src/features/hotkeys/components/HotkeyRecorder.vue b/apps/client/src/features/hotkeys/components/HotkeyRecorder.vue
index e6af8a1..a05bb8b 100644
--- a/apps/client/src/features/hotkeys/components/HotkeyRecorder.vue
+++ b/apps/client/src/features/hotkeys/components/HotkeyRecorder.vue
@@ -1,11 +1,18 @@
 <script setup lang="ts">
-import { captureHotkey, formatHotkeyParts } from '../lib/hotkey';
+import {
+  captureHotkey,
+  formatHotkeyParts,
+  HOTKEY_SUSPEND_EVENT,
+  HOTKEY_RESUME_EVENT,
+} from '../lib/hotkey';
 
 const props = defineProps<{
   /** Current accelerator string (e.g. "CommandOrControl+Alt+L"). */
   modelValue: string;
   /** Human label for the action this hotkey performs. */
   label: string;
+  /** Display-only (no keyboard to record, e.g. a phone) — hides the Change button. */
+  readonly?: boolean;
 }>();
 
 const emit = defineEmits<{
@@ -15,7 +22,7 @@ const emit = defineEmits<{
 const { t } = useI18n();
 
 const recording = ref(false);
-const error = ref<'invalid' | null>(null);
+const error = ref<'invalid' | 'altgr' | null>(null);
 
 const displayParts = computed(() => formatHotkeyParts(props.modelValue));
 
@@ -29,12 +36,17 @@ function startRecording(): void {
   currentRecorder = { cancel: stopRecording };
   recording.value = true;
   error.value = null;
+  // Drop all OS bindings so the captured combo reaches us instead of firing.
+  window.dispatchEvent(new Event(HOTKEY_SUSPEND_EVENT));
   window.addEventListener('keydown', onKey, { capture: true });
 }
 
 function stopRecording(): void {
+  if (!recording.value) return;
   recording.value = false;
   window.removeEventListener('keydown', onKey, { capture: true });
+  // Re-claim every binding (also re-applies an unchanged re-record).
+  window.dispatchEvent(new Event(HOTKEY_RESUME_EVENT));
   if (currentRecorder?.cancel === stopRecording) currentRecorder = null;
 }
 
@@ -47,6 +59,10 @@ function onKey(event: KeyboardEvent): void {
     stopRecording();
     return;
   }
+  if (result.error === 'altgr') {
+    error.value = 'altgr';
+    return;
+  }
   if (result.error === 'no-modifier' || result.error === 'bad-main-key') {
     error.value = 'invalid';
     return;
@@ -54,6 +70,8 @@ function onKey(event: KeyboardEvent): void {
   if (result.combo) {
     emit('update:modelValue', result.combo);
     error.value = null;
+    // stopRecording() resumes registration, re-claiming the combo even when the
+    // value is unchanged (a same-value write never trips the registration watch).
     stopRecording();
   }
 }
@@ -68,35 +86,39 @@ let currentRecorder: { cancel: () => void } | null = null;
 
 <template>
   <div>
-    <div class="mb-1.5 flex items-center justify-between gap-2">
-      <p class="text-xs opacity-60">{{ label }}</p>
+    <p class="mb-1 text-xs opacity-60">{{ label }}</p>
+    <!-- Combo chip + Change button on ONE line so the button is unambiguously
+         bound to the binding it edits (label sits on its own line above). -->
+    <div class="flex items-center justify-between gap-2">
+      <div
+        class="flex min-w-0 items-center gap-1 overflow-hidden rounded-md bg-surface-900/60 px-2 py-1.5 text-[11px] font-semibold tracking-wider"
+        :class="recording ? 'ring-2 ring-primary' : ''"
+      >
+        <template v-if="recording">
+          <span class="truncate opacity-70">{{ t('hotkeys.recordingPrompt') }}</span>
+        </template>
+        <template v-else>
+          <span v-for="(part, idx) in displayParts" :key="idx" class="inline-flex items-center">
+            <span class="rounded border border-surface-600 bg-surface-900 px-1.5 py-0.5 font-mono">
+              {{ part }}
+            </span>
+            <span v-if="idx < displayParts.length - 1" class="px-1 opacity-60">+</span>
+          </span>
+        </template>
+      </div>
       <Button
+        v-if="!readonly"
         :label="recording ? t('hotkeys.recording') : t('hotkeys.record')"
         size="small"
         severity="secondary"
         :outlined="!recording"
         :disabled="recording"
+        class="shrink-0"
         @click="startRecording"
       />
     </div>
-    <div
-      class="inline-flex items-center gap-1 rounded-md bg-surface-900/60 px-2 py-1.5 text-[11px] font-semibold tracking-wider"
-      :class="recording ? 'ring-2 ring-primary' : ''"
-    >
-      <template v-if="recording">
-        <span class="opacity-70">{{ t('hotkeys.recordingPrompt') }}</span>
-      </template>
-      <template v-else>
-        <span v-for="(part, idx) in displayParts" :key="idx" class="inline-flex items-center">
-          <span class="rounded border border-surface-600 bg-surface-900 px-1.5 py-0.5 font-mono">
-            {{ part }}
-          </span>
-          <span v-if="idx < displayParts.length - 1" class="px-1 opacity-60">+</span>
-        </span>
-      </template>
-    </div>
-    <p v-if="error === 'invalid'" class="mt-1.5 text-[10px] leading-relaxed text-amber-400">
-      {{ t('hotkeys.invalid') }}
+    <p v-if="error" class="mt-1.5 text-[10px] leading-relaxed text-amber-400">
+      {{ t(error === 'altgr' ? 'hotkeys.altgr' : 'hotkeys.invalid') }}
     </p>
   </div>
 </template>
diff --git a/apps/client/src/features/hotkeys/composables/useGlobalShortcut.ts b/apps/client/src/features/hotkeys/composables/useGlobalShortcut.ts
index 6a634df..a7f285c 100644
--- a/apps/client/src/features/hotkeys/composables/useGlobalShortcut.ts
+++ b/apps/client/src/features/hotkeys/composables/useGlobalShortcut.ts
@@ -1,3 +1,5 @@
+import { HOTKEY_SUSPEND_EVENT, HOTKEY_RESUME_EVENT } from '../lib/hotkey';
+
 /**
  * Register a Tauri global shortcut that mirrors a reactive combo string. On
  * mount we register the current combo; on every change the old combo is
@@ -5,6 +7,11 @@
  * (busy, invalid), the store ref is reverted to the previous value so the UI
  * keeps showing the actually-active hotkey.
  *
+ * While the settings recorder is capturing, every shortcut is suspended
+ * (unregistered) so the OS doesn't fire an action and swallow the keystroke —
+ * that's what lets you (re)bind a combo that's already taken, including itself.
+ * Resume re-claims the current value, which also re-applies an unchanged record.
+ *
  * In browser context all of this is a no-op so the same code lives in both.
  */
 export function useGlobalShortcut(isTauri: boolean, combo: Ref<string>, action: () => void): void {
@@ -12,66 +19,105 @@ export function useGlobalShortcut(isTauri: boolean, combo: Ref<string>, action:
   // Prevents the watch from looping when we revert combo.value after a
   // failed registration.
   let suppressNext = false;
+  // True while a recorder is capturing — hold no OS binding.
+  let suspended = false;
 
-  async function tryRegister(next: string): Promise<boolean> {
-    if (!isTauri) return false;
-    const { register, unregister } = await import('@tauri-apps/plugin-global-shortcut');
-    if (registered) {
+  // Serialize register/unregister ops. The change-watch and the recorder's
+  // resume can both fire a register for the same combo; without this they race,
+  // double-register, one throws "already registered", and the watch's failure
+  // path reverts the value the user just set.
+  let opChain: Promise<unknown> = Promise.resolve();
+  function enqueue<T>(task: () => Promise<T>): Promise<T> {
+    const run = opChain.then(task);
+    opChain = run.then(
+      () => undefined,
+      () => undefined,
+    );
+    return run;
+  }
+
+  function unregisterCurrent(): Promise<void> {
+    return enqueue(async () => {
+      if (!isTauri || !registered) return;
+      const { unregister } = await import('@tauri-apps/plugin-global-shortcut');
       try {
         await unregister(registered);
       } catch {
-        // Ignore — old binding may already be gone if the plugin reset state.
+        // Best-effort — the binding may already be gone.
       }
       registered = null;
-    }
-    // Defensive cleanup: an HMR reload may have left an orphan registration
-    // on the Rust side (old JS instance never got to onBeforeUnmount). Try
-    // to clear it before our new register call so the second attempt sticks.
-    try {
-      await unregister(next);
-    } catch {
-      // Expected when the combo isn't registered — that's fine.
-    }
-    try {
-      await register(next, (e) => {
-        // Plugin fires both "Pressed" and "Released" — trigger on Pressed only.
-        if (e.state === 'Pressed') action();
-      });
-      registered = next;
-      return true;
-    } catch (err) {
-      // eslint-disable-next-line no-console
-      console.error('[hotkey] failed to register', next, err);
-      return false;
-    }
+    });
+  }
+
+  function tryRegister(next: string): Promise<boolean> {
+    return enqueue(async () => {
+      if (!isTauri || suspended) return false;
+      // Already active (e.g. resume registered it just before this queued run).
+      if (next === registered) return true;
+      const { register, unregister } = await import('@tauri-apps/plugin-global-shortcut');
+      if (registered) {
+        try {
+          await unregister(registered);
+        } catch {
+          // Ignore — old binding may already be gone.
+        }
+        registered = null;
+      }
+      // Defensive: an HMR reload may have left an orphan registration on the
+      // Rust side; clear it before our register call so the attempt sticks.
+      try {
+        await unregister(next);
+      } catch {
+        // Expected when the combo isn't registered.
+      }
+      try {
+        await register(next, (e) => {
+          // Plugin fires both "Pressed" and "Released" — trigger on Pressed only.
+          if (e.state === 'Pressed') action();
+        });
+        registered = next;
+        return true;
+      } catch (err) {
+        // eslint-disable-next-line no-console
+        console.error('[hotkey] failed to register', next, err);
+        return false;
+      }
+    });
   }
 
   onMounted(() => {
     void tryRegister(combo.value);
   });
 
+  // The recorder brackets capture with suspend/resume so the pressed combo
+  // reaches the webview instead of firing its OS action.
+  useEventListener(window, HOTKEY_SUSPEND_EVENT, () => {
+    suspended = true;
+    void unregisterCurrent();
+  });
+  useEventListener(window, HOTKEY_RESUME_EVENT, () => {
+    suspended = false;
+    void tryRegister(combo.value);
+  });
+
   watch(combo, async (next, prev) => {
     if (suppressNext) {
       suppressNext = false;
       return;
     }
+    // Recording in progress — resume will re-register the final value.
+    if (suspended) return;
     const ok = await tryRegister(next);
-    if (!ok && prev) {
-      // Revert store value to the working combo so the UI doesn't lie.
+    // Don't revert if the combo did end up registered (a concurrent resume won
+    // the race) — only when it genuinely couldn't be claimed.
+    if (!ok && prev && registered !== next) {
       suppressNext = true;
       combo.value = prev;
       await tryRegister(prev);
     }
   });
 
-  onBeforeUnmount(async () => {
-    if (!isTauri || !registered) return;
-    const { unregister } = await import('@tauri-apps/plugin-global-shortcut');
-    try {
-      await unregister(registered);
-    } catch {
-      // Ignore — best-effort cleanup.
-    }
-    registered = null;
+  onBeforeUnmount(() => {
+    void unregisterCurrent();
   });
 }
diff --git a/apps/client/src/features/hotkeys/composables/useHotkeysSync.ts b/apps/client/src/features/hotkeys/composables/useHotkeysSync.ts
new file mode 100644
index 0000000..93a337f
--- /dev/null
+++ b/apps/client/src/features/hotkeys/composables/useHotkeysSync.ts
@@ -0,0 +1,34 @@
+import { useHotkeysStore } from '@/features/hotkeys/store';
+import { HOTKEY_SUSPEND_EVENT, HOTKEY_RESUME_EVENT } from '../lib/hotkey';
+import { suspendHotkeys, resumeHotkeys } from '@/features/server/api/hotkeys-api';
+import { useServerEvent } from '@/features/server/composables/useServerEvents';
+
+/**
+ * Mount once at the app root. Loads the backend-owned hotkey combos into the
+ * store and bridges the settings recorder's suspend/resume window events to
+ * the backend: while a recorder captures, the backend must drop its OS-global
+ * binds so the pressed combo reaches the page/webview instead of firing its
+ * action (the backend, not the browser, now holds those binds). The same
+ * window events still drive the client-side lock shortcut via `useGlobalShortcut`.
+ */
+export function useHotkeysSync(): void {
+  const store = useHotkeysStore();
+
+  onMounted(() => {
+    // Best-effort — a closed transport just leaves the defaults in place.
+    void store.load().catch(() => {});
+  });
+
+  // Another client rebound a combo → the backend broadcasts the effective
+  // config over SSE; apply it so this client's view stays in sync (e.g. the
+  // phone's read-only list). Browser/SSE only — the overlay is the rebind
+  // surface and already updates from its own PUT response.
+  useServerEvent('hotkeys', (msg) => store.applyConfig(msg.config));
+
+  useEventListener(window, HOTKEY_SUSPEND_EVENT, () => {
+    void suspendHotkeys().catch(() => {});
+  });
+  useEventListener(window, HOTKEY_RESUME_EVENT, () => {
+    void resumeHotkeys().catch(() => {});
+  });
+}
diff --git a/apps/client/src/features/hotkeys/lib/hotkey.ts b/apps/client/src/features/hotkeys/lib/hotkey.ts
index 5171042..38e00dc 100644
--- a/apps/client/src/features/hotkeys/lib/hotkey.ts
+++ b/apps/client/src/features/hotkeys/lib/hotkey.ts
@@ -25,6 +25,26 @@ const MODIFIER_DISPLAY: Readonly<Record<string, string>> = {
 /** Display labels for non-modifier main keys. Anything not listed falls back
  *  to an uppercased version of the token. */
 const KEY_DISPLAY: Readonly<Record<string, string>> = {
+  // Canonical numpad tokens — equal to KeyboardEvent.code, accepted verbatim
+  // by the global-hotkey crate (it uppercases before matching).
+  Numpad0: 'Num 0',
+  Numpad1: 'Num 1',
+  Numpad2: 'Num 2',
+  Numpad3: 'Num 3',
+  Numpad4: 'Num 4',
+  Numpad5: 'Num 5',
+  Numpad6: 'Num 6',
+  Numpad7: 'Num 7',
+  Numpad8: 'Num 8',
+  Numpad9: 'Num 9',
+  NumpadAdd: 'Num +',
+  NumpadSubtract: 'Num -',
+  NumpadMultiply: 'Num *',
+  NumpadDivide: 'Num /',
+  NumpadDecimal: 'Num .',
+  NumpadEnter: 'Num ↵',
+  // Legacy short tokens — only num0-9/numadd ever persisted (the others
+  // reverted on a failed register), kept so old binds still render right.
   num0: 'Num 0',
   num1: 'Num 1',
   num2: 'Num 2',
@@ -36,10 +56,6 @@ const KEY_DISPLAY: Readonly<Record<string, string>> = {
   num8: 'Num 8',
   num9: 'Num 9',
   numadd: 'Num +',
-  numsub: 'Num -',
-  nummult: 'Num *',
-  numdiv: 'Num /',
-  numdec: 'Num .',
   Up: '↑',
   Down: '↓',
   Left: '←',
@@ -58,6 +74,29 @@ const KEY_DISPLAY: Readonly<Record<string, string>> = {
 
 const MODIFIER_KEYS = new Set(['Control', 'Alt', 'Shift', 'Meta', 'OS']);
 
+// Physical modifier codes — matching on `event.code` is layout-independent, so
+// right-Alt (code "AltRight", key "AltGraph") is treated as a held modifier
+// rather than misread as a bad main key.
+const MODIFIER_CODES = new Set([
+  'ControlLeft',
+  'ControlRight',
+  'AltLeft',
+  'AltRight',
+  'ShiftLeft',
+  'ShiftRight',
+  'MetaLeft',
+  'MetaRight',
+  'OSLeft',
+  'OSRight',
+]);
+
+/** Window events the recorder fires to pause/resume all live global shortcuts
+ *  during capture. Without this the OS-registered combo fires its action and
+ *  swallows the keystroke, so an already-bound combo (incl. itself) can never
+ *  be re-captured. Resume re-claims every combo, re-applying unchanged ones. */
+export const HOTKEY_SUSPEND_EVENT = 'tc:hotkey-suspend';
+export const HOTKEY_RESUME_EVENT = 'tc:hotkey-resume';
+
 /**
  * Split an accelerator string into display-friendly parts (e.g. for rendering
  * inside `<kbd>` tags). Returns the input as-is if it doesn't look like a
@@ -79,7 +118,7 @@ interface CaptureResult {
   /** True when the user pressed Escape — caller should cancel recording. */
   cancelled: boolean;
   /** Reason the combo is invalid, or null if it's good. */
-  error: 'no-modifier' | 'bad-main-key' | null;
+  error: 'no-modifier' | 'bad-main-key' | 'altgr' | null;
 }
 
 /**
@@ -90,8 +129,15 @@ export function captureHotkey(event: KeyboardEvent): CaptureResult {
   if (event.key === 'Escape') {
     return { combo: null, cancelled: true, error: null };
   }
+  // Right Alt is AltGr on many layouts (Russian etc.): the OS delivers it as
+  // Ctrl+Alt, so a bind made with it fires inconsistently across layouts.
+  // Refuse it. AltGraph is set only by a real AltGr, not by a manual Ctrl+Alt,
+  // so legitimate Ctrl+Alt combos are unaffected.
+  if (event.getModifierState('AltGraph')) {
+    return { combo: null, cancelled: false, error: 'altgr' };
+  }
   // Holding only modifiers — wait for the main key.
-  if (MODIFIER_KEYS.has(event.key)) {
+  if (MODIFIER_KEYS.has(event.key) || MODIFIER_CODES.has(event.code)) {
     return { combo: null, cancelled: false, error: null };
   }
 
@@ -122,24 +168,29 @@ export function captureHotkey(event: KeyboardEvent): CaptureResult {
 
 // `KeyboardEvent.code` → Tauri accelerator token for non-letter/digit/F keys.
 const CODE_TO_ACCEL: Readonly<Record<string, string>> = {
-  // Numpad digits
-  Numpad0: 'num0',
-  Numpad1: 'num1',
-  Numpad2: 'num2',
-  Numpad3: 'num3',
-  Numpad4: 'num4',
-  Numpad5: 'num5',
-  Numpad6: 'num6',
-  Numpad7: 'num7',
-  Numpad8: 'num8',
-  Numpad9: 'num9',
-  // Numpad operators
-  NumpadAdd: 'numadd',
-  NumpadSubtract: 'numsub',
-  NumpadMultiply: 'nummult',
-  NumpadDivide: 'numdiv',
-  NumpadDecimal: 'numdec',
-  NumpadEnter: 'Enter',
+  // Numpad keys: emit the canonical W3C code (== KeyboardEvent.code). The
+  // global-hotkey crate uppercases and matches these verbatim; the old short
+  // tokens (numsub/nummult/numdiv/numdec) were NOT in its alias table, so they
+  // failed to register and silently reverted — only numadd/num0-9 happened to
+  // have aliases. Passing the canonical code makes every numpad key work.
+  Numpad0: 'Numpad0',
+  Numpad1: 'Numpad1',
+  Numpad2: 'Numpad2',
+  Numpad3: 'Numpad3',
+  Numpad4: 'Numpad4',
+  Numpad5: 'Numpad5',
+  Numpad6: 'Numpad6',
+  Numpad7: 'Numpad7',
+  Numpad8: 'Numpad8',
+  Numpad9: 'Numpad9',
+  NumpadAdd: 'NumpadAdd',
+  NumpadSubtract: 'NumpadSubtract',
+  NumpadMultiply: 'NumpadMultiply',
+  NumpadDivide: 'NumpadDivide',
+  NumpadDecimal: 'NumpadDecimal',
+  // Distinct from main Enter — registering 'Enter' here would never fire on the
+  // numpad key the user actually pressed.
+  NumpadEnter: 'NumpadEnter',
   // Punctuation (literal character tokens accepted by Tauri/Electron accel)
   Slash: '/',
   Backslash: '\\',
diff --git a/apps/client/src/features/hotkeys/settings.ts b/apps/client/src/features/hotkeys/settings.ts
index 7443e15..9c49655 100644
--- a/apps/client/src/features/hotkeys/settings.ts
+++ b/apps/client/src/features/hotkeys/settings.ts
@@ -3,8 +3,12 @@ import HotkeysSection from '@/features/settings/sections/HotkeysSection.vue';
 
 registerSettingsSection({
   id: 'hotkeys',
-  group: 'main',
-  order: 60,
-  visible: 'tauri',
+  order: 20,
+  // Shown everywhere — the combos are backend-owned and fire globally, so the
+  // bindings are worth seeing on any client. Rebinding needs a keyboard, so
+  // the rows go read-only on a phone (see HotkeysSection); the overlay + desktop
+  // browser stay editable.
+  visible: 'always',
+  titleKey: 'hotkeys.heading',
   component: HotkeysSection,
 });
diff --git a/apps/client/src/features/hotkeys/store.ts b/apps/client/src/features/hotkeys/store.ts
index fb8edf6..f4a2740 100644
--- a/apps/client/src/features/hotkeys/store.ts
+++ b/apps/client/src/features/hotkeys/store.ts
@@ -1,30 +1,112 @@
 import { z } from 'zod';
 import { persistedRef } from '@/shared/persisted-store';
+import { acceleratorSchema, type HotkeyConfig, type HotkeyPatch } from '@shared/hotkeys-api';
+import { fetchHotkeys, putHotkeys } from '@/features/server/api/hotkeys-api';
 
-// One or more modifiers + a non-empty main key. Bare keys (incl. F-row)
-// are rejected because Tarkov claims them via DirectInput and Tauri's
-// RegisterHotKey loses the race.
-const hotkeySchema = z
-  .string()
-  .regex(/^((CommandOrControl|Control|Ctrl|Alt|Shift|Meta|Super)\+)+[^+\s]+$/);
+// Default combos — must match the Rust `HotkeyConfig::default()` so an
+// un-customised install agrees on both ends and the migration below is a no-op.
+const DEFAULTS: HotkeyConfig = {
+  zoomIn: 'CommandOrControl+=',
+  zoomOut: 'CommandOrControl+-',
+  floorUp: 'CommandOrControl+Shift+=',
+  floorDown: 'CommandOrControl+Shift+-',
+  airdrop: 'CommandOrControl+Alt+D',
+};
 
+// localStorage keys the old client-owned store used (per-field persistedRefs).
+const LEGACY_KEYS: Record<keyof HotkeyConfig, string> = {
+  zoomIn: 'tc.hotkeys.zoomIn',
+  zoomOut: 'tc.hotkeys.zoomOut',
+  floorUp: 'tc.hotkeys.floorUp',
+  floorDown: 'tc.hotkeys.floorDown',
+  airdrop: 'tc.hotkeys.airdrop',
+};
+
+/** Read a legacy persistedRef value (stored as JSON) and validate it. */
+function readLegacy(key: string): string | null {
+  if (typeof localStorage === 'undefined') return null;
+  const raw = localStorage.getItem(key);
+  if (raw === null) return null;
+  try {
+    const parsed = acceleratorSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Hotkey settings store. The overlay **lock** combo stays client-owned (it
+ * toggles click-through — a window op, overlay-only — and is registered via
+ * `tauri-plugin-global-shortcut`; see CLAUDE.md). The five forwarded actions
+ * (zoom/floor/airdrop) are owned by the backend: this store is a thin sync
+ * layer that loads them via `fetchHotkeys()` and PUTs on change. Local refs
+ * start at the defaults so reads before `load()` are safe.
+ */
 export const useHotkeysStore = defineStore('hotkeys', () => {
-  const lockHotkey = persistedRef('tc.hotkeys.lock', hotkeySchema, 'CommandOrControl+Alt+L');
-  const zoomInHotkey = persistedRef('tc.hotkeys.zoomIn', hotkeySchema, 'CommandOrControl+=');
-  const zoomOutHotkey = persistedRef('tc.hotkeys.zoomOut', hotkeySchema, 'CommandOrControl+-');
-  const floorUpHotkey = persistedRef(
-    'tc.hotkeys.floorUp',
-    hotkeySchema,
-    'CommandOrControl+Shift+=',
-  );
-  const floorDownHotkey = persistedRef(
-    'tc.hotkeys.floorDown',
-    hotkeySchema,
-    'CommandOrControl+Shift+-',
-  );
-  // Hotkey only arms/clears at boundaries — sample capture is driven by
-  // the screenshot-watcher's `position` events, not this binding.
-  const airdropHotkey = persistedRef('tc.hotkeys.airdrop', hotkeySchema, 'CommandOrControl+Alt+D');
+  const lockHotkey = persistedRef('tc.hotkeys.lock', acceleratorSchema, 'CommandOrControl+Alt+L');
+
+  const zoomInHotkey = ref<string>(DEFAULTS.zoomIn);
+  const zoomOutHotkey = ref<string>(DEFAULTS.zoomOut);
+  const floorUpHotkey = ref<string>(DEFAULTS.floorUp);
+  const floorDownHotkey = ref<string>(DEFAULTS.floorDown);
+  const airdropHotkey = ref<string>(DEFAULTS.airdrop);
+
+  const fields: Record<keyof HotkeyConfig, Ref<string>> = {
+    zoomIn: zoomInHotkey,
+    zoomOut: zoomOutHotkey,
+    floorUp: floorUpHotkey,
+    floorDown: floorDownHotkey,
+    airdrop: airdropHotkey,
+  };
+
+  function applyConfig(cfg: HotkeyConfig): void {
+    for (const key of Object.keys(fields) as (keyof HotkeyConfig)[]) {
+      fields[key].value = cfg[key];
+    }
+  }
+
+  // One-time migration: if the user customised combos in the old localStorage
+  // store, push those up to the backend the first time the new client runs.
+  // Defaults match, so an un-customised install never PUTs anything.
+  const migrated = persistedRef('tc.hotkeys.migrated', z.boolean(), false);
+
+  async function migrateLegacy(backend: HotkeyConfig): Promise<void> {
+    if (migrated.value) return;
+    migrated.value = true;
+    const patch: HotkeyPatch = {};
+    for (const key of Object.keys(LEGACY_KEYS) as (keyof HotkeyConfig)[]) {
+      const legacy = readLegacy(LEGACY_KEYS[key]);
+      if (legacy && legacy !== backend[key]) {
+        patch[key] = legacy;
+      }
+    }
+    if (Object.keys(patch).length > 0) {
+      applyConfig(await putHotkeys(patch));
+    }
+  }
+
+  /** Load combos from the backend and run the one-time legacy migration.
+   * Mounted once at the app root (see `useHotkeysSync`). */
+  async function load(): Promise<void> {
+    const backend = await fetchHotkeys();
+    applyConfig(backend);
+    await migrateLegacy(backend);
+  }
+
+  /** Persist a single action's combo. Optimistically updates the local ref,
+   * then snaps to the backend's EFFECTIVE value (which reverts the field if
+   * the combo couldn't be registered); reverts on a rejected PUT (e.g. 400). */
+  async function setAction(field: keyof HotkeyConfig, combo: string): Promise<void> {
+    const prev = fields[field].value;
+    if (prev === combo) return;
+    fields[field].value = combo;
+    try {
+      applyConfig(await putHotkeys({ [field]: combo }));
+    } catch {
+      fields[field].value = prev;
+    }
+  }
 
   return {
     lockHotkey,
@@ -33,5 +115,8 @@ export const useHotkeysStore = defineStore('hotkeys', () => {
     floorUpHotkey,
     floorDownHotkey,
     airdropHotkey,
+    load,
+    setAction,
+    applyConfig,
   };
 });
diff --git a/apps/client/src/features/i18n/locales/en.json b/apps/client/src/features/i18n/locales/en.json
index 06627bd..9c4be7e 100644
--- a/apps/client/src/features/i18n/locales/en.json
+++ b/apps/client/src/features/i18n/locales/en.json
@@ -16,17 +16,27 @@
     "md": "M",
     "lg": "L"
   },
+  "edgeIndicators": "Edge arrows",
+  "edgeIndicatorsHint": "When zoomed in, show small arrows on the map edge pointing at off-screen extracts.",
   "player": "Player",
   "playerFollow": "Auto-follow",
-  "playerFollowHint": "Recenter and zoom the map on every new position update.",
+  "playerFollowHint": "Recenter the map on every new position, keeping your current zoom.",
   "playerFollowOptions": {
     "off": "Off",
+    "on": "On",
     "sm": "S",
     "md": "M",
     "lg": "L"
   },
   "settings": "Settings",
-  "systemSection": "System",
+  "position": "Position",
+  "settingsGroups": {
+    "player": "Player",
+    "loot": "Loot",
+    "quests": "Quests"
+  },
+  "close": "Close",
+  "floorWheelHint": "Floor — Alt + scroll to change",
   "floor": "Floor",
   "factions": {
     "pmc": "PMC",
@@ -34,13 +44,15 @@
     "shared": "Shared"
   },
   "paths": {
-    "heading": "Tarkov paths",
+    "heading": "Game integration",
     "gameDir": "Game folder",
     "screenshotsDir": "Screenshots folder",
     "save": "Save",
     "saved": "Saved",
     "loading": "Connecting to the helper…",
     "mobileHint": "Open this page on the machine running Tarkov to configure paths.",
+    "deleteScreenshots": "Delete screenshots after reading",
+    "deleteScreenshotsHint": "Sends each Tarkov screenshot to the Recycle Bin once its position has been read. Keeps the folder from filling up. Off by default.",
     "source": {
       "env": "from .env",
       "manual": "manual",
@@ -56,16 +68,31 @@
       "otherTitle": "Couldn't load Tarkov paths"
     }
   },
+  "updater": {
+    "available": "Update v{version} available",
+    "install": "Update",
+    "installing": "Updating…",
+    "error": "Update failed. Grab the new exe manually: GitHub → Releases."
+  },
   "overlay": {
     "heading": "Overlay",
     "alwaysOnTop": "Always on top",
+    "minimizeToTray": "Minimize to tray",
+    "minimizeToTrayHint": "Closing the window hides it to the system tray and keeps it running. Restore or quit from the tray icon.",
     "clickThrough": "Click-through",
     "clickThroughWarning": "Once enabled, you can't click the window. Restart the app to re-enable interaction.",
     "opacity": "Opacity",
     "mapOpacity": "Map opacity",
     "mapOpacityHint": "Available when overall opacity is below 100%.",
     "zoom": "Zoom",
-    "quickMenuTitle": "Transparency"
+    "quickMenuTitle": "Transparency",
+    "move": "Drag to move"
+  },
+  "display": {
+    "heading": "Display",
+    "fullscreen": "Fullscreen",
+    "fullscreenNA": "N/A",
+    "iosHint": "On iPhone, open this page in Safari, tap Share then “Add to Home Screen” for a full-screen, app-like view."
   },
   "pairing": {
     "heading": "Phone access",
@@ -81,6 +108,7 @@
   },
   "hotkeys": {
     "heading": "Hotkeys",
+    "rebindHint": "These fire globally from the PC. Rebind them in the overlay app on the PC — a phone has no keyboard to record a combo.",
     "lock": "Toggle lock",
     "lockHint": "Global shortcuts fire even when the game window is focused. Every binding needs at least one Ctrl / Alt / Shift.",
     "zoomIn": "Zoom in",
@@ -88,10 +116,14 @@
     "floorUp": "Next floor",
     "floorDown": "Previous floor",
     "airdrop": "Mark airdrop",
+    "floorWheel": "Floor by wheel",
+    "scroll": "Scroll",
+    "fixed": "Fixed shortcut — not rebindable",
     "record": "Change",
     "recording": "Recording…",
     "recordingPrompt": "Press the new combination (Esc to cancel)",
     "invalid": "Need at least one modifier (Ctrl/Alt/Shift).",
+    "altgr": "Right Alt (AltGr) can't be used — it's unreliable across layouts. Use Ctrl, Alt or Shift.",
     "conflict": "This combination is taken by another app. Try another."
   },
   "closeConfirm": {
@@ -100,6 +132,10 @@
     "accept": "Close",
     "reject": "Cancel"
   },
+  "trayHint": {
+    "title": "Still running",
+    "body": "tarkov-checker is now in the system tray. Open it from there, or right-click the tray icon to quit."
+  },
   "airdrop": {
     "armedFirst": "Drop tracker armed while facing the airdrop and press PrintScreen",
     "armedSecond": "Step sideways 5m, then press PrintScreen again",
@@ -113,10 +149,14 @@
     "radiusHint": "How big the predicted-landing circle is on the map. Two-shot triangulation isn't perfectly precise — the circle just makes the uncertainty honest. Adjust to taste."
   },
   "tray": {
-    "toggleLock": "Toggle lock",
+    "lock": "Lock (click-through)",
     "showWindow": "Show window",
+    "alwaysOnTop": "Always on top",
+    "playerFollow": "Player follow",
+    "pairPhone": "Pair phone",
+    "copyUrl": "Copy LAN URL",
     "quit": "Quit",
-    "tooltip": "tarkov-checker"
+    "tooltip": "tarkov-checker — running"
   },
   "extractNames": {
     "bigmap": {
diff --git a/apps/client/src/features/i18n/locales/ru.json b/apps/client/src/features/i18n/locales/ru.json
index bd36a37..1a1df13 100644
--- a/apps/client/src/features/i18n/locales/ru.json
+++ b/apps/client/src/features/i18n/locales/ru.json
@@ -16,17 +16,27 @@
     "md": "M",
     "lg": "L"
   },
+  "edgeIndicators": "Стрелки к выходам",
+  "edgeIndicatorsHint": "На приближении показывает у края карты маленькие стрелки к выходам за пределами экрана.",
   "player": "Игрок",
   "playerFollow": "Авто-следование",
-  "playerFollowHint": "Центрируем и приближаем карту при каждом новом обновлении позиции.",
+  "playerFollowHint": "Центрирует карту при каждой новой позиции, сохраняя текущий зум.",
   "playerFollowOptions": {
     "off": "Выкл",
+    "on": "Вкл",
     "sm": "S",
     "md": "M",
     "lg": "L"
   },
   "settings": "Настройки",
-  "systemSection": "Системные",
+  "position": "Позиция",
+  "settingsGroups": {
+    "player": "Игрок",
+    "loot": "Лут",
+    "quests": "Квесты"
+  },
+  "close": "Закрыть",
+  "floorWheelHint": "Уровень — Alt + колесо для смены",
   "floor": "Уровень",
   "factions": {
     "pmc": "ЧВК",
@@ -34,13 +44,15 @@
     "shared": "Общие"
   },
   "paths": {
-    "heading": "Пути Tarkov",
+    "heading": "Интеграция с игрой",
     "gameDir": "Папка с игрой",
     "screenshotsDir": "Папка скриншотов",
     "save": "Сохранить",
     "saved": "Сохранено",
     "loading": "Подключаемся к хелперу…",
     "mobileHint": "Открой эту страницу на машине с Tarkov, чтобы настроить пути.",
+    "deleteScreenshots": "Удалять скриншоты после считывания",
+    "deleteScreenshotsHint": "Отправляет каждый скриншот Tarkov в корзину после считывания позиции. Не даёт папке разрастаться. По умолчанию выключено.",
     "source": {
       "env": "из .env",
       "manual": "вручную",
@@ -56,16 +68,31 @@
       "otherTitle": "Не удалось загрузить пути Tarkov"
     }
   },
+  "updater": {
+    "available": "Доступно обновление v{version}",
+    "install": "Обновить",
+    "installing": "Обновляем…",
+    "error": "Не получилось обновиться. Скачай новый exe вручную: GitHub → Releases."
+  },
   "overlay": {
     "heading": "Оверлей",
     "alwaysOnTop": "Поверх всех окон",
+    "minimizeToTray": "Сворачивать в трей",
+    "minimizeToTrayHint": "При закрытии окно прячется в системный трей и продолжает работать. Развернуть или выйти — через значок в трее.",
     "clickThrough": "Прозрачное для кликов",
     "clickThroughWarning": "После включения окно перестанет реагировать на мышь. Чтобы вернуть взаимодействие — перезапусти приложение.",
     "opacity": "Прозрачность",
     "mapOpacity": "Прозрачность карты",
     "mapOpacityHint": "Доступно когда общая прозрачность ниже 100%.",
     "zoom": "Масштаб",
-    "quickMenuTitle": "Прозрачность"
+    "quickMenuTitle": "Прозрачность",
+    "move": "Перетащить"
+  },
+  "display": {
+    "heading": "Дисплей",
+    "fullscreen": "Полный экран",
+    "fullscreenNA": "Недоступно",
+    "iosHint": "На iPhone открой эту страницу в Safari, нажми «Поделиться» → «На экран «Домой»» — получишь полноэкранный режим как у приложения."
   },
   "pairing": {
     "heading": "Доступ с телефона",
@@ -81,6 +108,7 @@
   },
   "hotkeys": {
     "heading": "Хоткеи",
+    "rebindHint": "Срабатывают глобально с ПК. Переопределить можно в оверлее на ПК — на телефоне нет клавиатуры для записи комбинации.",
     "lock": "Переключить блокировку",
     "lockHint": "Глобальные хоткеи — срабатывают даже когда фокус в окне игры. Каждый биндинг требует хотя бы один Ctrl / Alt / Shift.",
     "zoomIn": "Приблизить",
@@ -88,10 +116,14 @@
     "floorUp": "Следующий этаж",
     "floorDown": "Предыдущий этаж",
     "airdrop": "Отметить дроп",
+    "floorWheel": "Этаж колёсиком",
+    "scroll": "Колесо",
+    "fixed": "Фиксированный — не переназначается",
     "record": "Изменить",
     "recording": "Запись…",
     "recordingPrompt": "Нажми новое сочетание (Esc — отмена)",
     "invalid": "Нужен хотя бы один модификатор (Ctrl/Alt/Shift).",
+    "altgr": "Правый Alt (AltGr) использовать нельзя — он нестабилен между раскладками. Используй Ctrl, Alt или Shift.",
     "conflict": "Это сочетание уже занято другим приложением. Попробуй другое."
   },
   "closeConfirm": {
@@ -100,6 +132,10 @@
     "accept": "Закрыть",
     "reject": "Отмена"
   },
+  "trayHint": {
+    "title": "Работает в фоне",
+    "body": "tarkov-checker свёрнут в системный трей. Открой его оттуда или нажми правый клик по иконке, чтобы выйти."
+  },
   "airdrop": {
     "armedFirst": "Drop-трекер запущен, смотри на дроп и нажми PrintScreen",
     "armedSecond": "Отойди на 5м в сторону и нажми PrintScreen ещё раз",
@@ -113,10 +149,14 @@
     "radiusHint": "Размер круга предполагаемого места падения на карте. Триангуляция по двум снимкам не идеально точная — круг просто честно показывает погрешность. Подбери на свой вкус."
   },
   "tray": {
-    "toggleLock": "Переключить блокировку",
+    "lock": "Блокировка (клики сквозь)",
     "showWindow": "Показать окно",
+    "alwaysOnTop": "Поверх всех окон",
+    "playerFollow": "Авто-следование",
+    "pairPhone": "Подключить телефон",
+    "copyUrl": "Копировать LAN-ссылку",
     "quit": "Выход",
-    "tooltip": "tarkov-checker"
+    "tooltip": "tarkov-checker — работает"
   },
   "extractNames": {
     "bigmap": {
diff --git a/apps/client/src/features/i18n/settings.ts b/apps/client/src/features/i18n/settings.ts
index e4ad521..ded6e08 100644
--- a/apps/client/src/features/i18n/settings.ts
+++ b/apps/client/src/features/i18n/settings.ts
@@ -1,4 +1,9 @@
 import { registerSettingsSection } from '@/features/settings/registry';
 import LanguageSection from '@/features/settings/sections/LanguageSection.vue';
 
-registerSettingsSection({ id: 'language', group: 'system', order: 10, component: LanguageSection });
+registerSettingsSection({
+  id: 'language',
+  order: 30,
+  titleKey: 'language',
+  component: LanguageSection,
+});
diff --git a/apps/client/src/features/i18n/store.ts b/apps/client/src/features/i18n/store.ts
index c61a5a5..5be7b2e 100644
--- a/apps/client/src/features/i18n/store.ts
+++ b/apps/client/src/features/i18n/store.ts
@@ -4,8 +4,18 @@ import { persistedRef } from '@/shared/persisted-store';
 const apiLangSchema = z.enum(['en', 'ru']);
 export type ApiLang = z.infer<typeof apiLangSchema>;
 
+// First-launch default: match the system/browser language when we support it,
+// else fall back to English. Only consulted when nothing is persisted yet, so a
+// later manual choice always wins.
+function detectInitialLang(): ApiLang {
+  if (typeof navigator !== 'undefined' && navigator.language?.toLowerCase().startsWith('ru')) {
+    return 'ru';
+  }
+  return 'en';
+}
+
 export const useI18nStore = defineStore('i18n', () => {
-  const apiLang = persistedRef('tc.i18n.apiLang', apiLangSchema, 'en' as ApiLang);
+  const apiLang = persistedRef('tc.i18n.apiLang', apiLangSchema, detectInitialLang());
 
   // Mirror the persisted apiLang into the vue-i18n instance: on first read
   // (initial value), and on every subsequent change. `setLocale` is lazy —
diff --git a/apps/client/src/features/map/components/FloorSwitcher.vue b/apps/client/src/features/map/components/FloorSwitcher.vue
deleted file mode 100644
index 89acabc..0000000
--- a/apps/client/src/features/map/components/FloorSwitcher.vue
+++ /dev/null
@@ -1,96 +0,0 @@
-<script setup lang="ts">
-interface Floor {
-  readonly id: string;
-  readonly label: string;
-}
-
-const props = defineProps<{
-  floors: ReadonlyArray<Floor>;
-  current: string | null;
-}>();
-
-const { t } = useI18n();
-
-const emit = defineEmits<{
-  (e: 'select', id: string): void;
-}>();
-
-const open = ref(false);
-const root = ref<HTMLElement | null>(null);
-
-const currentLabel = computed(() => {
-  const match = props.floors.find((f) => f.id === props.current);
-  return match?.label ?? props.floors[0]?.label ?? '';
-});
-
-function toggle(): void {
-  open.value = !open.value;
-}
-function select(id: string): void {
-  emit('select', id);
-  open.value = false;
-}
-function onDocumentClick(event: MouseEvent): void {
-  if (!open.value) return;
-  if (root.value && !root.value.contains(event.target as Node)) {
-    open.value = false;
-  }
-}
-function onKey(event: KeyboardEvent): void {
-  if (event.key === 'Escape' && open.value) open.value = false;
-}
-onMounted(() => {
-  document.addEventListener('mousedown', onDocumentClick);
-  document.addEventListener('keydown', onKey);
-});
-onBeforeUnmount(() => {
-  document.removeEventListener('mousedown', onDocumentClick);
-  document.removeEventListener('keydown', onKey);
-});
-</script>
-
-<template>
-  <div ref="root" class="relative">
-    <Transition
-      enter-active-class="transition duration-150 ease-out"
-      enter-from-class="opacity-0 translate-y-1"
-      enter-to-class="opacity-100 translate-y-0"
-      leave-active-class="transition duration-100 ease-in"
-      leave-from-class="opacity-100 translate-y-0"
-      leave-to-class="opacity-0 translate-y-1"
-    >
-      <div
-        v-if="open"
-        class="absolute bottom-12 left-0 flex flex-col gap-1.5"
-        role="listbox"
-        aria-orientation="vertical"
-        :aria-label="t('floor')"
-      >
-        <Button
-          v-for="floor in floors"
-          :key="floor.id"
-          rounded
-          size="small"
-          :severity="floor.id === current ? 'primary' : 'secondary'"
-          :label="floor.label"
-          role="option"
-          :aria-selected="floor.id === current"
-          :aria-label="'Floor ' + floor.label"
-          @click="select(floor.id)"
-        />
-      </div>
-    </Transition>
-
-    <Button
-      size="small"
-      severity="secondary"
-      class="!bg-surface-800/80 hover:!bg-surface-800 !border-surface-700 backdrop-blur"
-      :aria-expanded="open"
-      aria-haspopup="listbox"
-      :aria-label="t('floor')"
-      @click="toggle"
-    >
-      {{ t('floor') }}: {{ currentLabel }}
-    </Button>
-  </div>
-</template>
diff --git a/apps/client/src/features/map/components/LayerRail.vue b/apps/client/src/features/map/components/LayerRail.vue
new file mode 100644
index 0000000..418a804
--- /dev/null
+++ b/apps/client/src/features/map/components/LayerRail.vue
@@ -0,0 +1,298 @@
+<script setup lang="ts">
+import { useMapLayers, type MapLayer } from '../layers/registry';
+import { useOverlayLock } from '@/features/overlay/composables/useOverlayLock';
+import { useLayerVisibility } from '../composables/useLayerVisibility';
+import { setRailObstacle } from '../composables/useRailObstacle';
+import { isTauri } from '@/shared/tauri';
+import MapSection from '@/features/settings/sections/MapSection.vue';
+
+const props = defineProps<{
+  floors?: ReadonlyArray<{ id: string; label: string }>;
+  currentFloor?: string | null;
+}>();
+const emit = defineEmits<{ (e: 'selectFloor', id: string): void }>();
+
+const { t } = useI18n();
+const mapLayers = useMapLayers();
+const isDesktop = useMediaQuery('(min-width: 640px)');
+
+// A layer's rail row can be context-gated (defaults to 'always'); the layer
+// still mounts on the map regardless — this only hides the toggle row.
+function available(l: MapLayer): boolean {
+  const a = l.availability ?? 'always';
+  if (a === 'always') return true;
+  if (a === 'tauri') return isTauri;
+  return isTauri || isDesktop.value;
+}
+const visibleLayers = computed(() => mapLayers.value.filter(available));
+
+// Presentation metadata only — icon + order, plus the "future" categories we
+// tease as dimmed placeholders. Which LAYERS fall under each comes from the
+// registry's `category` field, not from here.
+const CATEGORY_META = [
+  { key: 'player', icon: 'pi-user' },
+  { key: 'loot', icon: 'pi-box' },
+  { key: 'quests', icon: 'pi-flag' },
+] as const;
+
+const categories = computed(() =>
+  CATEGORY_META.map((c) => ({
+    key: c.key,
+    icon: c.icon,
+    label: t(`settingsGroups.${c.key}`),
+    layers: visibleLayers.value
+      .filter((l) => l.category === c.key)
+      .sort((a, b) => a.order - b.order),
+  })),
+);
+
+// Own the visibility refs in setup scope (cached singletons; cheap thereafter).
+const layerVis = useLayerVisibility;
+visibleLayers.value.forEach((l) => layerVis(l.id));
+
+// 'map' = base map selector flyout; otherwise a category key.
+const openId = ref<string | null>(null);
+const expanded = ref<string | null>(null);
+const railRef = ref<HTMLElement | null>(null);
+const flyoutRef = ref<HTMLElement | null>(null);
+
+// Hide the rail (animated) while the overlay is click-through-locked.
+const { locked, showControls } = useOverlayLock();
+const railVisible = showControls;
+
+function toggle(id: string): void {
+  openId.value = openId.value === id ? null : id;
+  expanded.value = null;
+}
+
+onClickOutside(flyoutRef, (e) => {
+  if (railRef.value?.contains(e.target as Node)) return;
+  openId.value = null;
+});
+
+watch(locked, (isLocked) => {
+  if (isLocked) {
+    openId.value = null;
+    setRailObstacle(null); // arrows reflow to the true edge as the rail fades out
+  }
+});
+
+useEventListener(window, 'blur', () => {
+  openId.value = null;
+});
+
+// Publish the rail's rect (viewport coords) so edge-indicator layers can wrap
+// around it without scraping the DOM. Republish whenever it appears or moves.
+function publishRail(): void {
+  const el = railRef.value;
+  if (!el) {
+    setRailObstacle(null);
+    return;
+  }
+  const r = el.getBoundingClientRect();
+  setRailObstacle({ left: r.left, right: r.right, top: r.top, bottom: r.bottom, width: r.width });
+}
+onMounted(publishRail);
+useEventListener(window, 'resize', publishRail);
+onBeforeUnmount(() => setRailObstacle(null));
+
+const openCategory = computed(() => categories.value.find((c) => c.key === openId.value) ?? null);
+const isMapOpen = computed(() => openId.value === 'map');
+
+// Floor stepper at the rail's bottom (multi-floor maps only). Floors are ordered
+// top-to-bottom (index 0 = top), so "up" steps toward index 0.
+const floorList = computed(() => props.floors ?? []);
+const hasFloors = computed(() => floorList.value.length > 1);
+const floorIndex = computed(() => floorList.value.findIndex((f) => f.id === props.currentFloor));
+const currentFloorLabel = computed(
+  () => floorList.value[Math.max(0, floorIndex.value)]?.label ?? '',
+);
+const canFloorUp = computed(() => floorIndex.value > 0);
+const canFloorDown = computed(
+  () => floorIndex.value >= 0 && floorIndex.value < floorList.value.length - 1,
+);
+function stepFloor(delta: number): void {
+  const i = floorIndex.value < 0 ? 0 : floorIndex.value;
+  const target = floorList.value[i + delta];
+  if (target) emit('selectFloor', target.id);
+}
+</script>
+
+<template>
+  <Transition name="rail" @after-enter="publishRail">
+    <div
+      v-if="railVisible"
+      ref="railRef"
+      class="layer-rail border-surface-700 bg-surface-900/85 absolute left-0 top-1/2 z-[1100] flex flex-col gap-1 rounded-r-xl border border-l-0 p-1 backdrop-blur"
+    >
+      <button
+        v-tooltip.right="{ value: t('map'), disabled: openId !== null }"
+        type="button"
+        class="rail-btn"
+        :class="{ 'rail-btn--active': isMapOpen }"
+        :aria-label="t('map')"
+        @click="toggle('map')"
+      >
+        <i class="pi pi-map" />
+      </button>
+      <div class="bg-surface-700 my-0.5 h-px" />
+      <button
+        v-for="c in categories"
+        :key="c.key"
+        v-tooltip.right="{ value: c.label, disabled: openId !== null }"
+        type="button"
+        class="rail-btn"
+        :class="{ 'rail-btn--active': openId === c.key, 'rail-btn--empty': c.layers.length === 0 }"
+        :disabled="c.layers.length === 0"
+        :aria-label="c.label"
+        @click="toggle(c.key)"
+      >
+        <i class="pi" :class="c.icon" />
+      </button>
+
+      <!-- Floor stepper (multi-floor maps): glanceable current floor + ▲/▼. -->
+      <template v-if="hasFloors">
+        <div class="bg-surface-700 my-0.5 h-px" />
+        <button
+          type="button"
+          class="rail-btn"
+          :disabled="!canFloorUp"
+          :aria-label="t('floor') + ' +'"
+          @click="stepFloor(-1)"
+        >
+          <i class="pi pi-chevron-up text-sm" />
+        </button>
+        <div
+          v-tooltip.right="{ value: t('floorWheelHint'), disabled: openId !== null }"
+          class="flex h-5 items-center justify-center text-xs font-semibold tabular-nums opacity-80"
+        >
+          {{ currentFloorLabel }}
+        </div>
+        <button
+          type="button"
+          class="rail-btn"
+          :disabled="!canFloorDown"
+          :aria-label="t('floor') + ' -'"
+          @click="stepFloor(1)"
+        >
+          <i class="pi pi-chevron-down text-sm" />
+        </button>
+      </template>
+
+      <!-- Flyout positioned relative to the rail (vertically centred), NOT
+           `position: fixed` which drifted in the Tauri WebView2 overlay. No
+           nested overlays inside (map = inline Listbox, sections inline). -->
+      <div
+        v-if="openId"
+        ref="flyoutRef"
+        class="layer-rail__flyout border-surface-700 bg-surface-900/95 absolute left-full top-1/2 ml-1.5 max-h-[80svh] w-60 overflow-y-auto rounded-xl border p-3 shadow-xl backdrop-blur"
+      >
+        <template v-if="isMapOpen">
+          <p class="mb-2 text-[10px] font-semibold uppercase tracking-wider opacity-50">
+            {{ t('map') }}
+          </p>
+          <MapSection />
+        </template>
+        <template v-else-if="openCategory">
+          <p class="mb-2 text-[10px] font-semibold uppercase tracking-wider opacity-50">
+            {{ openCategory.label }}
+          </p>
+          <div
+            v-for="l in openCategory.layers"
+            :key="l.id"
+            class="border-surface-800 border-b py-1.5 last:border-0"
+          >
+            <div class="flex items-center gap-2">
+              <ToggleSwitch
+                :model-value="layerVis(l.id).value"
+                @update:model-value="(v: boolean) => (layerVis(l.id).value = v)"
+              />
+              <span class="flex-1 truncate text-sm">{{ t(l.titleKey) }}</span>
+              <button
+                v-if="l.settingsComponent"
+                type="button"
+                class="hover:bg-surface-800 flex h-8 w-8 shrink-0 items-center justify-center rounded opacity-70 hover:opacity-100"
+                :class="{ 'text-primary-400 bg-surface-800 !opacity-100': expanded === l.id }"
+                :aria-label="t('settings')"
+                @click="expanded = expanded === l.id ? null : l.id"
+              >
+                <i class="pi pi-cog text-sm" />
+              </button>
+            </div>
+            <div v-if="l.settingsComponent && expanded === l.id" class="mt-2 pl-1">
+              <component :is="l.settingsComponent" />
+            </div>
+          </div>
+        </template>
+      </div>
+    </div>
+  </Transition>
+
+  <!-- Locked: rail hidden, but keep a read-only floor read-out so the current
+       level stays glanceable while click-through is on. -->
+  <div
+    v-if="locked && hasFloors"
+    class="sa-bottom sa-left border-surface-700 bg-surface-900/85 absolute z-[1100] flex items-center gap-1.5 rounded-md border px-2 py-1 backdrop-blur"
+  >
+    <i class="pi pi-clone text-[10px] opacity-50" />
+    <span class="text-xs font-semibold tabular-nums">{{ currentFloorLabel }}</span>
+  </div>
+</template>
+
+<style scoped>
+/* Vertical centring via a literal transform, NOT Tailwind's `-translate-y-1/2`.
+   Tailwind v4's translate utilities rely on @property-registered `--tw-*` vars,
+   which Safari < 16.4 (iOS 15) ignores — the composed `translate` declaration
+   then turns invalid and centring silently breaks. A plain transform works on
+   every Safari. (Paired with `top-1/2` in the template.) */
+.layer-rail,
+.layer-rail__flyout {
+  transform: translateY(-50%);
+}
+
+.rail-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 2rem;
+  height: 2rem;
+  border-radius: 0.5rem;
+  color: var(--p-surface-300);
+  transition:
+    background-color 0.12s,
+    color 0.12s;
+}
+.rail-btn:hover {
+  background-color: var(--p-surface-800);
+  color: var(--p-surface-0);
+}
+.rail-btn--active {
+  background-color: color-mix(in srgb, var(--p-primary-500) 22%, transparent);
+  color: var(--p-primary-300);
+}
+.rail-btn--empty {
+  opacity: 0.3;
+  cursor: default;
+}
+.rail-btn:disabled {
+  opacity: 0.25;
+  cursor: default;
+}
+.rail-btn:disabled:hover {
+  background-color: transparent;
+  color: var(--p-surface-300);
+}
+
+/* Rail slide/fade when the overlay locks/unlocks. */
+.rail-enter-active,
+.rail-leave-active {
+  transition:
+    opacity 0.18s ease,
+    left 0.18s ease;
+}
+.rail-enter-from,
+.rail-leave-to {
+  opacity: 0;
+  left: -3rem;
+}
+</style>
diff --git a/apps/client/src/features/map/components/MapView.vue b/apps/client/src/features/map/components/MapView.vue
index 22c046f..35343b8 100644
--- a/apps/client/src/features/map/components/MapView.vue
+++ b/apps/client/src/features/map/components/MapView.vue
@@ -1,9 +1,10 @@
 <script setup lang="ts">
 import { useLeafletMap } from '../composables/useLeafletMap';
 import { useMapLayers } from '../layers/registry';
+import { useLayerVisibility } from '../composables/useLayerVisibility';
 import { useMapI18n } from '../composables/useMapI18n';
 import { mapInfo, type TarkovMapCode } from '@shared/maps';
-import FloorSwitcher from './FloorSwitcher.vue';
+import LayerRail from './LayerRail.vue';
 
 const props = defineProps<{
   mapCode: TarkovMapCode;
@@ -28,18 +29,44 @@ const {
   setActiveFloor,
   zoomIn,
   zoomOut,
-  nextFloor,
-  prevFloor,
+  floorUp,
+  floorDown,
   reload,
 } = useLeafletMap(mapContainer, props.mapCode);
 
 for (const layer of useMapLayers().value) {
-  layer.mount({ map, mapCode: props.mapCode, mapInfo: info, initialZoom });
+  layer.mount({
+    map,
+    mapCode: props.mapCode,
+    mapInfo: info,
+    initialZoom,
+    visible: useLayerVisibility(layer.id),
+  });
 }
 
-const hasFloors = computed(() => info.floors.length > 1);
+// Alt + mouse wheel over the map steps floors instead of zooming (multi-floor
+// maps only). Captured before Leaflet's own wheel handler so it never zooms;
+// lightly throttled so a trackpad doesn't skip several floors at once.
+let lastFloorWheel = 0;
+useEventListener(
+  mapContainer,
+  'wheel',
+  (e: WheelEvent) => {
+    if (!e.altKey || info.floors.length <= 1) return;
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    const now = performance.now();
+    if (now - lastFloorWheel < 120) return;
+    lastFloorWheel = now;
+    const floors = info.floors;
+    const i = floors.findIndex((f) => f.id === currentFloor.value);
+    const target = floors[(i < 0 ? 0 : i) + (e.deltaY < 0 ? -1 : 1)];
+    if (target) setActiveFloor(target.id);
+  },
+  { capture: true, passive: false },
+);
 
-defineExpose({ zoomIn, zoomOut, nextFloor, prevFloor, reload });
+defineExpose({ zoomIn, zoomOut, floorUp, floorDown, reload });
 
 watch(
   locale,
@@ -53,7 +80,5 @@ watch(mapError, (err) => emit('mapError', err));
 
 <template>
   <div ref="mapContainer" class="absolute inset-0 z-0" />
-  <div v-if="hasFloors" class="absolute bottom-3 left-3 z-[1000]">
-    <FloorSwitcher :floors="info.floors" :current="currentFloor" @select="setActiveFloor" />
-  </div>
+  <LayerRail :floors="info.floors" :current-floor="currentFloor" @select-floor="setActiveFloor" />
 </template>
diff --git a/apps/client/src/features/map/composables/useFloorSwitcher.ts b/apps/client/src/features/map/composables/useFloorSwitcher.ts
index f046f7a..853004f 100644
--- a/apps/client/src/features/map/composables/useFloorSwitcher.ts
+++ b/apps/client/src/features/map/composables/useFloorSwitcher.ts
@@ -11,8 +11,10 @@ interface FloorInfo {
 export interface UseFloorSwitcher {
   currentFloor: Ref<string | null>;
   setActiveFloor: (id: string) => void;
-  nextFloor: () => void;
-  prevFloor: () => void;
+  /** Step to a higher floor (toward the top of the list); clamps at the topmost. */
+  floorUp: () => void;
+  /** Step to a lower floor (toward the bottom); clamps at the lowest. */
+  floorDown: () => void;
 }
 
 /**
@@ -70,25 +72,27 @@ export function useFloorSwitcher(
     currentFloor.value = id;
   }
 
+  // Floors are ordered top-to-bottom (index 0 = highest), so "up" steps toward
+  // index 0. Clamp at both ends — no wrap-around, so repeated presses at the top
+  // or bottom do nothing (matches the rail stepper's disabled-at-edge buttons).
   function shiftFloor(delta: 1 | -1): void {
     const floorIds = floors.map((f) => f.id);
     if (floorIds.length <= 1) return;
     const active = currentFloor.value ?? defaultFloor;
     if (active === null) return;
-    const idx = floorIds.indexOf(active);
-    // Wrap around so repeated presses cycle the list.
-    const nextIdx = (idx + delta + floorIds.length) % floorIds.length;
+    const nextIdx = floorIds.indexOf(active) + delta;
+    if (nextIdx < 0 || nextIdx >= floorIds.length) return;
     const next = floorIds[nextIdx];
     if (next) setActiveFloor(next);
   }
 
-  function nextFloor(): void {
-    shiftFloor(1);
+  function floorUp(): void {
+    shiftFloor(-1);
   }
 
-  function prevFloor(): void {
-    shiftFloor(-1);
+  function floorDown(): void {
+    shiftFloor(1);
   }
 
-  return { currentFloor, setActiveFloor, nextFloor, prevFloor };
+  return { currentFloor, setActiveFloor, floorUp, floorDown };
 }
diff --git a/apps/client/src/features/map/composables/useLayerVisibility.ts b/apps/client/src/features/map/composables/useLayerVisibility.ts
new file mode 100644
index 0000000..4d5604b
--- /dev/null
+++ b/apps/client/src/features/map/composables/useLayerVisibility.ts
@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { effectScope, type Ref } from 'vue';
+import { persistedRef } from '@/shared/persisted-store';
+
+// One shared visibility ref per layer id (module-level singleton) so the on-map
+// LayerRail toggle and the Leaflet layer composable read/write the SAME ref.
+//
+// Created inside a DETACHED effect scope so the localStorage watch that
+// `persistedRef` installs lives for the whole process. Created naively, that
+// watch is owned by whichever component first calls this (MapView's setup) and
+// gets disposed on the next map switch (`:key="mapCode"` remount) — silently
+// stopping persistence. This scope is never stopped.
+const scope = effectScope(true);
+const refs = new Map<string, Ref<boolean>>();
+
+export function useLayerVisibility(id: string): Ref<boolean> {
+  const cached = refs.get(id);
+  if (cached) return cached;
+  // scope.run only returns undefined if the scope is stopped; ours never is.
+  const r = scope.run(() =>
+    persistedRef(`tc.layer.${id}.visible`, z.boolean(), true),
+  ) as Ref<boolean>;
+  refs.set(id, r);
+  return r;
+}
diff --git a/apps/client/src/features/map/composables/useLeafletMap.ts b/apps/client/src/features/map/composables/useLeafletMap.ts
index b9494f6..4ce8d81 100644
--- a/apps/client/src/features/map/composables/useLeafletMap.ts
+++ b/apps/client/src/features/map/composables/useLeafletMap.ts
@@ -14,7 +14,9 @@ interface UseLeafletMapResult extends UseFloorSwitcher {
   reload: () => void;
 }
 
-const PAN_PAD = 0.15;
+// Generous panning room beyond the map edges + soft (not rigid) bounds, so
+// dragging the map around doesn't hit a hard wall.
+const PAN_PAD = 0.5;
 
 function applyRotation(latLng: L.LatLng, rotationDeg: number): L.LatLng {
   if (rotationDeg === 0) return latLng;
@@ -118,7 +120,7 @@ export function useLeafletMap(
       minZoom: -5,
       maxZoom: 4,
       zoomSnap: 0.25,
-      maxBoundsViscosity: 1.0,
+      maxBoundsViscosity: 0.5,
     });
     map.value = instance;
     const markersPane = instance.createPane('extracts');
diff --git a/apps/client/src/features/map/composables/useRailObstacle.ts b/apps/client/src/features/map/composables/useRailObstacle.ts
new file mode 100644
index 0000000..6c32076
--- /dev/null
+++ b/apps/client/src/features/map/composables/useRailObstacle.ts
@@ -0,0 +1,32 @@
+import { ref, type Ref } from 'vue';
+
+/**
+ * The on-map LayerRail's bounding rect in VIEWPORT coordinates (px), or null
+ * when the rail is hidden. Published by `LayerRail.vue`; consumed by
+ * edge-indicator layers so off-screen-marker arrows can wrap around the rail
+ * WITHOUT scraping the DOM (`document.querySelector('.layer-rail')`) or knowing
+ * anything about overlay-lock state. Reactive, so consumers can `watch` it and
+ * repaint as the rail appears / moves / disappears.
+ *
+ * A module-level singleton: there is exactly one rail. Future chrome that
+ * off-screen indicators should avoid can extend this into a list.
+ */
+export interface RailRect {
+  readonly left: number;
+  readonly right: number;
+  readonly top: number;
+  readonly bottom: number;
+  readonly width: number;
+}
+
+const railRect = ref<RailRect | null>(null);
+
+/** Read side — edge-indicator layers. */
+export function useRailObstacle(): Ref<RailRect | null> {
+  return railRect;
+}
+
+/** Write side — the LayerRail publishes its rect (or null when hidden). */
+export function setRailObstacle(rect: RailRect | null): void {
+  railRect.value = rect;
+}
diff --git a/apps/client/src/features/map/layers/airdrop/index.ts b/apps/client/src/features/map/layers/airdrop/index.ts
index 0b4825b..de39ef8 100644
--- a/apps/client/src/features/map/layers/airdrop/index.ts
+++ b/apps/client/src/features/map/layers/airdrop/index.ts
@@ -1,4 +1,12 @@
 import { registerMapLayer } from '../registry';
 import { useAirdropLayer } from './useAirdropLayer';
+import AirdropSection from '@/features/settings/sections/AirdropSection.vue';
 
-registerMapLayer({ id: 'airdrop', mount: useAirdropLayer });
+registerMapLayer({
+  id: 'airdrop',
+  mount: useAirdropLayer,
+  category: 'player',
+  order: 30,
+  titleKey: 'airdrop.settingsHeading',
+  settingsComponent: AirdropSection,
+});
diff --git a/apps/client/src/features/map/layers/airdrop/useAirdropLayer.ts b/apps/client/src/features/map/layers/airdrop/useAirdropLayer.ts
index 88c481e..fc3068e 100644
--- a/apps/client/src/features/map/layers/airdrop/useAirdropLayer.ts
+++ b/apps/client/src/features/map/layers/airdrop/useAirdropLayer.ts
@@ -18,7 +18,7 @@ import type { MapLayerContext } from '../registry';
  * extract icons but below the player marker.
  */
 export function useAirdropLayer(ctx: MapLayerContext): void {
-  const { map } = ctx;
+  const { map, visible } = ctx;
   const store = useAirdropStore();
   let dropAreaCircle: L.Circle | null = null;
 
@@ -46,7 +46,8 @@ export function useAirdropLayer(ctx: MapLayerContext): void {
 
   // The circle stays through `confirmingClear` — the user is about to wipe
   // it, they should see exactly what they're about to lose.
-  const showDrop = (): boolean => store.phase === 'result' || store.phase === 'confirmingClear';
+  const showDrop = (): boolean =>
+    visible.value && (store.phase === 'result' || store.phase === 'confirmingClear');
 
   watch(
     () => store.phase,
@@ -73,5 +74,10 @@ export function useAirdropLayer(ctx: MapLayerContext): void {
     if (showDrop()) placeDrop();
   });
 
+  watch(visible, () => {
+    clearAll();
+    if (showDrop()) placeDrop();
+  });
+
   onBeforeUnmount(clearAll);
 }
diff --git a/apps/client/src/features/map/layers/extracts/index.ts b/apps/client/src/features/map/layers/extracts/index.ts
index 1d5e48c..8797c5d 100644
--- a/apps/client/src/features/map/layers/extracts/index.ts
+++ b/apps/client/src/features/map/layers/extracts/index.ts
@@ -1,4 +1,12 @@
 import { registerMapLayer } from '../registry';
 import { useExtractsLayer } from './useExtractsLayer';
+import ExtractsSection from '@/features/settings/sections/ExtractsSection.vue';
 
-registerMapLayer({ id: 'extracts', mount: useExtractsLayer });
+registerMapLayer({
+  id: 'extracts',
+  mount: useExtractsLayer,
+  category: 'player',
+  order: 20,
+  titleKey: 'extracts',
+  settingsComponent: ExtractsSection,
+});
diff --git a/apps/client/src/features/map/layers/extracts/useEdgeIndicators.ts b/apps/client/src/features/map/layers/extracts/useEdgeIndicators.ts
new file mode 100644
index 0000000..d10ed31
--- /dev/null
+++ b/apps/client/src/features/map/layers/extracts/useEdgeIndicators.ts
@@ -0,0 +1,135 @@
+import type { Map as LeafletMap } from 'leaflet';
+
+/** One off-screen target: position in (lat=z, lng=x) + the arrow colour. */
+export interface EdgeArrow {
+  lat: number;
+  lng: number;
+  color: string;
+}
+
+/** An obstacle (the on-map rail) in viewport coords that left-edge arrows wrap
+ * around. Supplied by the caller — this util never touches the DOM for it. */
+export interface EdgeObstacle {
+  readonly right: number;
+  readonly top: number;
+  readonly bottom: number;
+  readonly width: number;
+}
+
+const MARGIN = 18; // px inset from the container edge
+const ARROW_PX = 22;
+const RAIL_GAP = 16; // arrow-centre offset past the rail's right edge
+const RAIL_PAD = 6; // extend the avoid band slightly past the rail's top/bottom
+
+/**
+ * Renders small arrows on the viewport edge pointing at off-screen extracts.
+ *
+ * The arrows live in a plain overlay `<div>` appended to the Leaflet container
+ * (NOT a map pane) so they stay pixel-fixed to the viewport — a marker in a
+ * pane would be dragged around by the pane transform during a pan. On every
+ * map move/zoom we recompute each target's container point; off-screen ones get
+ * an arrow clamped to the inset rectangle edge, rotated to point outward.
+ */
+export function createEdgeIndicators(
+  map: LeafletMap,
+  getArrows: () => EdgeArrow[],
+  getObstacle: () => EdgeObstacle | null = () => null,
+) {
+  const overlay = document.createElement('div');
+  overlay.className = 'edge-indicators';
+  map.getContainer().appendChild(overlay);
+
+  const pool: HTMLElement[] = [];
+
+  function take(i: number): HTMLElement {
+    let el = pool[i];
+    if (!el) {
+      el = document.createElement('div');
+      el.className = 'edge-indicator';
+      // Thick dark outline (drawn behind the fill via paint-order) so the
+      // small coloured arrow reads on any part of the busy map.
+      el.innerHTML = `<svg viewBox="0 0 24 24" width="${ARROW_PX}" height="${ARROW_PX}" aria-hidden="true"><path d="M12 3 L20 19 L12 15 L4 19 Z" fill="currentColor" stroke="#0a0b0d" stroke-width="3" stroke-linejoin="round" paint-order="stroke"/></svg>`;
+      overlay.appendChild(el);
+      pool[i] = el;
+    }
+    return el;
+  }
+
+  function update(): void {
+    const size = map.getSize();
+    const cx = size.x / 2;
+    const cy = size.y / 2;
+    const halfW = cx - MARGIN;
+    const halfH = cy - MARGIN;
+
+    // The on-map left rail is an obstacle: left-edge arrows whose y falls within
+    // its vertical span get pushed out to the rail's right edge, so they wrap
+    // around the panel instead of hiding behind it. The obstacle rect (viewport
+    // coords) is supplied by the caller and converted into container coords here;
+    // null when the rail is hidden (locked overlay), so arrows revert to the edge.
+    const obstacle = getObstacle();
+    let avoid: { right: number; top: number; bottom: number } | null = null;
+    if (obstacle && obstacle.width > 0) {
+      const containerRect = map.getContainer().getBoundingClientRect();
+      avoid = {
+        right: obstacle.right - containerRect.left,
+        top: obstacle.top - containerRect.top,
+        bottom: obstacle.bottom - containerRect.top,
+      };
+    }
+
+    let used = 0;
+    for (const a of getArrows()) {
+      const cp = map.latLngToContainerPoint([a.lat, a.lng]);
+      if (cp.x >= 0 && cp.x <= size.x && cp.y >= 0 && cp.y <= size.y) continue; // on-screen
+      const dx = cp.x - cx;
+      const dy = cp.y - cy;
+      if (dx === 0 && dy === 0) continue;
+      const t = Math.min(
+        dx !== 0 ? halfW / Math.abs(dx) : Infinity,
+        dy !== 0 ? halfH / Math.abs(dy) : Infinity,
+      );
+      let ex = cx + dx * t;
+      const ey = cy + dy * t;
+      // Wrap a left-edge arrow around the rail panel when it'd land behind it.
+      // Only ever push rightward — as the rail slides out (lock), its right edge
+      // moves left of the arrow and the push naturally stops, so arrows glide
+      // back to the true edge instead of chasing the panel off-screen.
+      if (
+        avoid &&
+        dx < 0 &&
+        ex <= MARGIN + 1 &&
+        ey >= avoid.top - RAIL_PAD &&
+        ey <= avoid.bottom + RAIL_PAD &&
+        avoid.right + RAIL_GAP > ex
+      ) {
+        ex = avoid.right + RAIL_GAP;
+      }
+      const deg = (Math.atan2(dy, dx) * 180) / Math.PI + 90; // SVG arrow points up
+      const el = take(used);
+      el.style.left = `${ex}px`;
+      el.style.top = `${ey}px`;
+      el.style.transform = `rotate(${deg}deg)`;
+      el.style.color = a.color;
+      el.style.display = '';
+      used++;
+    }
+    for (let i = used; i < pool.length; i++) {
+      const el = pool[i];
+      if (el) el.style.display = 'none';
+    }
+  }
+
+  const onMove = (): void => update();
+  map.on('move zoom zoomend viewreset resize', onMove);
+  update();
+
+  return {
+    update,
+    destroy(): void {
+      map.off('move zoom zoomend viewreset resize', onMove);
+      overlay.remove();
+      pool.length = 0;
+    },
+  };
+}
diff --git a/apps/client/src/features/map/layers/extracts/useExtractsLayer.ts b/apps/client/src/features/map/layers/extracts/useExtractsLayer.ts
index 6742ab1..1f243e2 100644
--- a/apps/client/src/features/map/layers/extracts/useExtractsLayer.ts
+++ b/apps/client/src/features/map/layers/extracts/useExtractsLayer.ts
@@ -1,8 +1,11 @@
 import L, { type Marker, type LayerGroup } from 'leaflet';
+import { FACTION_COLORS } from '@shared/maps';
 import { makeIcon } from './icon';
 import { buildTooltipHtml, sortedEntries, type ExtractEntry } from './tooltip';
+import { createEdgeIndicators, type EdgeArrow } from './useEdgeIndicators';
 import { extractsForMap } from '@/features/map/data/extracts';
 import { useMapSettingsStore } from '@/features/map/store';
+import { useRailObstacle } from '@/features/map/composables/useRailObstacle';
 import type { MapLayerContext } from '../registry';
 
 export type LabelMode = 'hover' | 'always';
@@ -33,12 +36,14 @@ interface RawExtract {
 }
 
 export function useExtractsLayer(ctx: MapLayerContext): void {
-  const { map, mapCode } = ctx;
+  const { map, mapCode, visible } = ctx;
   const { t, locale } = useI18n();
-  const { extractFactions, extractLabelMode, extractLabelSize } =
+  const { extractFactions, extractLabelMode, extractLabelSize, edgeIndicators } =
     storeToRefs(useMapSettingsStore());
+  const railRect = useRailObstacle();
 
   let extractsLayer: LayerGroup | null = null;
+  let edge: ReturnType<typeof createEdgeIndicators> | null = null;
   const entries: MarkerEntry[] = [];
   const state = {
     visibleFactions: new Set<string>(extractFactions.value),
@@ -80,6 +85,34 @@ export function useExtractsLayer(ctx: MapLayerContext): void {
         extractsLayer.removeLayer(entry.marker);
       }
     }
+    edge?.update();
+  }
+
+  // Off-screen extract arrows (opt-in). One arrow per visible merged extract,
+  // coloured by its first visible faction; the overlay itself decides which
+  // are off-screen on each map move.
+  function arrowData(): EdgeArrow[] {
+    const out: EdgeArrow[] = [];
+    for (const entry of entries) {
+      const first = effectiveEntries(entry)[0];
+      if (!first) continue;
+      out.push({
+        lat: entry.extract.position.z,
+        lng: entry.extract.position.x,
+        color: FACTION_COLORS[first.faction],
+      });
+    }
+    return out;
+  }
+
+  function syncEdge(): void {
+    if (edgeIndicators.value && visible.value && map.value) {
+      if (edge) edge.update();
+      else edge = createEdgeIndicators(map.value, arrowData, () => railRect.value);
+    } else if (edge) {
+      edge.destroy();
+      edge = null;
+    }
   }
 
   function reopenAllPermanentTooltips(): void {
@@ -97,6 +130,14 @@ export function useExtractsLayer(ctx: MapLayerContext): void {
     return v === i18nKey ? ex.key : v;
   }
 
+  function applyVisible(): void {
+    if (!map.value || !extractsLayer) return;
+    const has = map.value.hasLayer(extractsLayer);
+    if (visible.value && !has) extractsLayer.addTo(map.value);
+    if (!visible.value && has) map.value.removeLayer(extractsLayer);
+    syncEdge();
+  }
+
   function loadExtracts(): void {
     const data = extractsForMap(mapCode);
     if (!data) {
@@ -149,6 +190,8 @@ export function useExtractsLayer(ctx: MapLayerContext): void {
       entries.push({ marker, extract: ex });
     }
     refreshMarkers();
+    syncEdge();
+    applyVisible();
   }
 
   // Single source of truth for "the map exists now": loads markers + attaches
@@ -162,11 +205,16 @@ export function useExtractsLayer(ctx: MapLayerContext): void {
       if (m) {
         m.on('click', reopenAllPermanentTooltips);
         loadExtracts();
+      } else if (edge) {
+        edge.destroy();
+        edge = null;
       }
     },
     { immediate: true },
   );
 
+  watch(edgeIndicators, syncEdge);
+
   watch(locale, () => {
     loadExtracts();
   });
@@ -176,6 +224,12 @@ export function useExtractsLayer(ctx: MapLayerContext): void {
     refreshMarkers();
   });
 
+  watch(visible, applyVisible);
+
+  // The LayerRail publishes its rect (and null when it hides on lock); repaint
+  // the edge arrows whenever it changes so they re-flow around the rail.
+  watch(railRect, () => edge?.update());
+
   watch(extractLabelMode, (mode) => {
     if (state.labelMode === mode) return;
     state.labelMode = mode;
@@ -201,6 +255,8 @@ export function useExtractsLayer(ctx: MapLayerContext): void {
   );
 
   onBeforeUnmount(() => {
+    edge?.destroy();
+    edge = null;
     if (extractsLayer && map.value) {
       map.value.removeLayer(extractsLayer);
     }
diff --git a/apps/client/src/features/map/layers/player/index.ts b/apps/client/src/features/map/layers/player/index.ts
index eb0115f..4f9d938 100644
--- a/apps/client/src/features/map/layers/player/index.ts
+++ b/apps/client/src/features/map/layers/player/index.ts
@@ -1,4 +1,12 @@
 import { registerMapLayer } from '../registry';
 import { usePlayerLayer } from './usePlayerLayer';
+import PlayerSection from '@/features/settings/sections/PlayerSection.vue';
 
-registerMapLayer({ id: 'player', mount: usePlayerLayer });
+registerMapLayer({
+  id: 'player',
+  mount: usePlayerLayer,
+  category: 'player',
+  order: 10,
+  titleKey: 'position',
+  settingsComponent: PlayerSection,
+});
diff --git a/apps/client/src/features/map/layers/player/usePlayerLayer.ts b/apps/client/src/features/map/layers/player/usePlayerLayer.ts
index bc24f15..1fef56e 100644
--- a/apps/client/src/features/map/layers/player/usePlayerLayer.ts
+++ b/apps/client/src/features/map/layers/player/usePlayerLayer.ts
@@ -3,13 +3,8 @@ import { useServerEvent } from '@/features/server/composables/useServerEvents';
 import { useMapSettingsStore } from '@/features/map/store';
 import type { MapLayerContext } from '../registry';
 
-export type PlayerFollow = 'off' | 'sm' | 'md' | 'lg';
-
-const FOLLOW_ZOOM_DELTA: Readonly<Record<Exclude<PlayerFollow, 'off'>, number>> = {
-  sm: 1,
-  md: 2,
-  lg: 3,
-};
+// Follow simply recenters on every new position, keeping the user's zoom.
+export type PlayerFollow = 'off' | 'on';
 
 function buildPlayerIconHtml(displayYaw: number | null): string {
   if (displayYaw === null) {
@@ -19,7 +14,7 @@ function buildPlayerIconHtml(displayYaw: number | null): string {
 }
 
 export function usePlayerLayer(ctx: MapLayerContext): void {
-  const { map, mapInfo, initialZoom } = ctx;
+  const { map, mapInfo, visible } = ctx;
   const mapRotation = mapInfo.rotation;
   const yawOffset = mapInfo.yawOffset ?? 0;
 
@@ -38,7 +33,8 @@ export function usePlayerLayer(ctx: MapLayerContext): void {
     if (!map.value) return;
     const latLng: LatLngExpression = [pos.z, pos.x];
     if (!playerLayer) {
-      playerLayer = L.layerGroup().addTo(map.value);
+      playerLayer = L.layerGroup();
+      if (visible.value) playerLayer.addTo(map.value);
     }
     const displayYaw = yaw === null ? null : yaw + mapRotation + yawOffset;
     const icon = L.divIcon({
@@ -61,12 +57,9 @@ export function usePlayerLayer(ctx: MapLayerContext): void {
     }
 
     const changed = pos.x !== lastX || pos.z !== lastZ || yaw !== lastYaw;
-    if (changed && playerFollow.value !== 'off') {
-      const targetZoom = Math.min(
-        initialZoom.value + FOLLOW_ZOOM_DELTA[playerFollow.value],
-        map.value.getMaxZoom(),
-      );
-      map.value.setView(latLng, targetZoom, { animate: true, duration: 0.4 });
+    if (changed && playerFollow.value === 'on') {
+      // Recenter only — keep whatever zoom the user has set.
+      map.value.panTo(latLng, { animate: true, duration: 0.4 });
     }
     if (changed) {
       lastX = pos.x;
@@ -75,6 +68,14 @@ export function usePlayerLayer(ctx: MapLayerContext): void {
     }
   }
 
+  function applyVisible(): void {
+    if (!playerLayer || !map.value) return;
+    const has = map.value.hasLayer(playerLayer);
+    if (visible.value && !has) playerLayer.addTo(map.value);
+    if (!visible.value && has) map.value.removeLayer(playerLayer);
+  }
+  watch(visible, applyVisible);
+
   useServerEvent('position', (msg) => {
     setPlayerPosition({ x: msg.x, y: msg.y, z: msg.z }, msg.yaw ?? null);
   });
diff --git a/apps/client/src/features/map/layers/registry.ts b/apps/client/src/features/map/layers/registry.ts
index 4b59a78..26b9804 100644
--- a/apps/client/src/features/map/layers/registry.ts
+++ b/apps/client/src/features/map/layers/registry.ts
@@ -1,4 +1,11 @@
-import { computed, shallowReactive, type ComputedRef, type Ref, type ShallowRef } from 'vue';
+import {
+  computed,
+  shallowReactive,
+  type Component,
+  type ComputedRef,
+  type Ref,
+  type ShallowRef,
+} from 'vue';
 import type { Map as LeafletMap } from 'leaflet';
 import type { TarkovMapCode, TarkovMapInfo } from '@shared/maps';
 
@@ -7,27 +14,46 @@ export interface MapLayerContext {
   mapCode: TarkovMapCode;
   mapInfo: TarkovMapInfo;
   initialZoom: Ref<number>;
+  /** Per-layer visibility, driven by the on-map LayerRail toggle. The layer's
+   * composable watches this and adds/removes its Leaflet root accordingly. */
+  visible: Ref<boolean>;
 }
 
+/** Rail category a layer is grouped under (a section of the on-map LayerRail). */
+export type LayerCategory = 'player' | 'loot' | 'quests';
+
+/** Context gate for a layer's rail row. Defaults to 'always'. The layer still
+ * mounts on the map regardless — this only hides the toggle row. */
+export type LayerAvailability = 'always' | 'tauri' | 'desktop-or-tauri';
+
 export interface MapLayer {
   id: string;
   mount: (ctx: MapLayerContext) => void;
+  /** Rail category this layer is grouped under. */
+  category: LayerCategory;
+  /** Ascending order within the category; use multiples of 10. */
+  order: number;
+  /** i18n key for the layer's display name (rail row + flyout header). */
+  titleKey: string;
+  /** Optional per-layer settings, rendered inline in the rail flyout via a gear. */
+  settingsComponent?: Component;
+  availability?: LayerAvailability;
 }
 
+// Single source of truth for a layer: what mounts on the map AND how the rail
+// presents/toggles/configures it. No second registry, no cross-registry id
+// matching — `useLayerVisibility(layer.id)` keys off these same ids.
 const registry = shallowReactive(new Map<string, MapLayer>());
 
+// HMR-safe: replace by id instead of duplicating on hot-reload.
 export function registerMapLayer(layer: MapLayer): void {
   registry.set(layer.id, layer);
 }
 
 /**
- * Read-once snapshot of registered layers. `MapView.vue` iterates this in
- * setup() and mounts each layer; layers added later (e.g. through dynamic
- * feature flags) won't appear without a `MapView` remount — which is what
- * `:key="mapCode"` already does on map switch. The ComputedRef wrapper is
- * kept for HMR: when a layer's index.ts is hot-reloaded, the reactive
- * registry mutation invalidates this computed so the next remount picks
- * up the new entry.
+ * Reactive snapshot of registered layers. `MapView.vue` mounts each in setup();
+ * `LayerRail.vue` reads it to build the category icons + flyouts. shallowReactive
+ * so late registrations (dev HMR) re-track the computed.
  */
 export function useMapLayers(): ComputedRef<MapLayer[]> {
   return computed(() => [...registry.values()]);
diff --git a/apps/client/src/features/map/settings.ts b/apps/client/src/features/map/settings.ts
deleted file mode 100644
index 8907cdb..0000000
--- a/apps/client/src/features/map/settings.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { registerSettingsSection } from '@/features/settings/registry';
-import MapSection from '@/features/settings/sections/MapSection.vue';
-import ExtractsSection from '@/features/settings/sections/ExtractsSection.vue';
-import PlayerSection from '@/features/settings/sections/PlayerSection.vue';
-
-registerSettingsSection({ id: 'map', group: 'main', order: 10, component: MapSection });
-registerSettingsSection({ id: 'extracts', group: 'main', order: 20, component: ExtractsSection });
-registerSettingsSection({ id: 'player', group: 'main', order: 30, component: PlayerSection });
diff --git a/apps/client/src/features/map/store.ts b/apps/client/src/features/map/store.ts
index f2507a9..30f2f54 100644
--- a/apps/client/src/features/map/store.ts
+++ b/apps/client/src/features/map/store.ts
@@ -6,7 +6,7 @@ import type { PlayerFollow } from './layers/player/usePlayerLayer';
 const extractFactionSchema = z.enum(['pmc', 'scav', 'shared']);
 const labelModeSchema = z.enum(['hover', 'always']);
 const labelSizeSchema = z.enum(['sm', 'md', 'lg']);
-const playerFollowSchema = z.enum(['off', 'sm', 'md', 'lg']);
+const playerFollowSchema = z.enum(['off', 'on']);
 const mapCodeSchema = z.string().refine((s): s is TarkovMapCode => s in TARKOV_MAPS);
 const autoMapSwitchSchema = z.boolean();
 
@@ -31,6 +31,8 @@ export const useMapSettingsStore = defineStore('map-settings', () => {
     labelSizeSchema,
     'md' as ExtractLabelSize,
   );
+  // Off-screen extract arrows on the viewport edge. Opt-in, off by default.
+  const edgeIndicators = persistedRef('tc.map.edgeIndicators', z.boolean(), false);
   const playerFollow = persistedRef(
     'tc.map.playerFollow',
     playerFollowSchema,
@@ -43,6 +45,7 @@ export const useMapSettingsStore = defineStore('map-settings', () => {
     extractFactions,
     extractLabelMode,
     extractLabelSize,
+    edgeIndicators,
     playerFollow,
     autoMapSwitch,
   };
diff --git a/apps/client/src/features/overlay/components/MapQuickMenu.vue b/apps/client/src/features/overlay/components/MapQuickMenu.vue
index 7279208..1d48471 100644
--- a/apps/client/src/features/overlay/components/MapQuickMenu.vue
+++ b/apps/client/src/features/overlay/components/MapQuickMenu.vue
@@ -34,6 +34,12 @@ useEventListener(window, 'keydown', (e) => {
   if (e.key === 'Escape' && position.value) close();
 });
 
+// Close when the overlay loses focus or is hidden (e.g. Alt+Tab, lock).
+useEventListener(window, 'blur', () => close());
+useEventListener(document, 'visibilitychange', () => {
+  if (document.visibilityState === 'hidden') close();
+});
+
 defineExpose({ open, close });
 </script>
 
diff --git a/apps/client/src/features/overlay/components/MapSwitchMenu.vue b/apps/client/src/features/overlay/components/MapSwitchMenu.vue
new file mode 100644
index 0000000..b9426ac
--- /dev/null
+++ b/apps/client/src/features/overlay/components/MapSwitchMenu.vue
@@ -0,0 +1,87 @@
+<script setup lang="ts">
+import { VISIBLE_MAP_CODES, type TarkovMapCode } from '@shared/maps';
+import { useMapSettingsStore } from '@/features/map/store';
+import { useMapI18n } from '@/features/map/composables/useMapI18n';
+
+// Right-click-the-map-name → quick map switcher. Same teleported-popup pattern
+// as MapQuickMenu (open(x,y) / outside-click / Esc / blur dismissal).
+const { mapCode } = storeToRefs(useMapSettingsStore());
+const { localizedMapName } = useMapI18n();
+
+const position = ref<{ x: number; y: number } | null>(null);
+const panelRef = ref<HTMLElement | null>(null);
+
+const PANEL_W = 208;
+const PANEL_H = 360;
+const EDGE_GAP = 8;
+
+const maps = computed(() =>
+  VISIBLE_MAP_CODES.map((code) => ({ code, name: localizedMapName(code) })),
+);
+
+function open(x: number, y: number): void {
+  position.value = {
+    x: Math.max(EDGE_GAP, Math.min(x, window.innerWidth - PANEL_W - EDGE_GAP)),
+    y: Math.max(EDGE_GAP, Math.min(y, window.innerHeight - PANEL_H - EDGE_GAP)),
+  };
+}
+
+function close(): void {
+  position.value = null;
+}
+
+function select(code: TarkovMapCode): void {
+  mapCode.value = code;
+  close();
+}
+
+onClickOutside(panelRef, () => close());
+useEventListener(window, 'keydown', (e) => {
+  if (e.key === 'Escape' && position.value) close();
+});
+useEventListener(window, 'blur', () => close());
+useEventListener(document, 'visibilitychange', () => {
+  if (document.visibilityState === 'hidden') close();
+});
+
+defineExpose({ open, close });
+</script>
+
+<template>
+  <Teleport to="body">
+    <Transition
+      enter-active-class="transition duration-100 ease-out"
+      enter-from-class="opacity-0 scale-95"
+      enter-to-class="opacity-100 scale-100"
+      leave-active-class="transition duration-75 ease-in"
+      leave-from-class="opacity-100 scale-100"
+      leave-to-class="opacity-0 scale-95"
+    >
+      <div
+        v-if="position"
+        ref="panelRef"
+        class="fixed z-[2000] max-h-[80vh] w-52 origin-top-left overflow-y-auto rounded-md border border-surface-700 bg-surface-900/95 p-1 shadow-xl backdrop-blur"
+        :style="{ left: position.x + 'px', top: position.y + 'px' }"
+        role="menu"
+      >
+        <button
+          v-for="m in maps"
+          :key="m.code"
+          type="button"
+          role="menuitemradio"
+          :aria-checked="m.code === mapCode"
+          class="flex w-full items-center gap-2 rounded px-2 py-1.5 text-left text-sm hover:bg-surface-800"
+          :class="m.code === mapCode ? 'font-medium text-primary-400' : ''"
+          @click="select(m.code)"
+        >
+          <i
+            class="pi text-[10px]"
+            :class="m.code === mapCode ? 'pi-check' : 'pi-circle'"
+            aria-hidden="true"
+          />
+          <span class="truncate">{{ m.name }}</span>
+        </button>
+      </div>
+    </Transition>
+  </Teleport>
+</template>
diff --git a/apps/client/src/features/overlay/components/OverlayBorder.vue b/apps/client/src/features/overlay/components/OverlayBorder.vue
new file mode 100644
index 0000000..91e238d
--- /dev/null
+++ b/apps/client/src/features/overlay/components/OverlayBorder.vue
@@ -0,0 +1,15 @@
+<script setup lang="ts">
+// Animated dashed boundary for the unlocked overlay. An SVG stroke (not a CSS
+// border) so the marching-ants dashes follow the rounded corners cleanly.
+// Teleported to <body> so it sits outside #app, which the opacity slider dims.
+</script>
+
+<template>
+  <Teleport to="body">
+    <svg class="overlay-border" aria-hidden="true" xmlns="http://www.w3.org/2000/svg">
+      <!-- pathLength normalizes the perimeter to 100 units so the dash pattern
+           divides evenly and closes without a seam at any window size. -->
+      <rect pathLength="100" />
+    </svg>
+  </Teleport>
+</template>
diff --git a/apps/client/src/features/overlay/components/OverlayHeader.vue b/apps/client/src/features/overlay/components/OverlayHeader.vue
index 11246f1..1c74356 100644
--- a/apps/client/src/features/overlay/components/OverlayHeader.vue
+++ b/apps/client/src/features/overlay/components/OverlayHeader.vue
@@ -1,17 +1,24 @@
 <script setup lang="ts">
 import SettingsPanel from '@/features/settings/SettingsPanel.vue';
+import MapSwitchMenu from './MapSwitchMenu.vue';
+import { isTauri } from '@/shared/tauri';
+import { useOverlayHeaderActive } from '../composables/useOverlayHeaderActive';
+import { useOverlayLock } from '../composables/useOverlayLock';
 import type { TransportStatus } from '@/features/server/composables/useServerTransport';
 
 interface Props {
-  mapDisplayName: string;
   status: TransportStatus;
-  isTauri: boolean;
-  overlayClickThrough: boolean;
+  /** Render the Tauri overlay chrome (true under real Tauri, or the dev
+   *  preview flag). Native window calls still guard on the real `isTauri`. */
+  tauriChrome: boolean;
 }
 
 const props = defineProps<Props>();
 defineEmits<{ close: [] }>();
 
+const { t } = useI18n();
+const { locked, showControls } = useOverlayLock();
+
 const statusIconClass = computed(() => {
   switch (props.status) {
     case 'open':
@@ -25,57 +32,138 @@ const statusIconClass = computed(() => {
   }
 });
 
-// Drag region — explicit @mousedown rather than data-tauri-drag-region,
-// which is flaky on decorations:false + transparent:true windows.
+// Shared with sibling chrome (the floating clock slides down when this is
+// active). The bar expands on hover and must STAY expanded while dragging —
+// the OS move loop steals pointer events, so `:hover` drops the instant the
+// drag starts. Track dragging explicitly and clear it on release: mouseup, or
+// the first button-less mousemove as a fallback if the OS swallowed the mouseup.
+const { hovered, dragging, active: dragBarActive } = useOverlayHeaderActive();
+
+useEventListener(window, 'mouseup', () => {
+  dragging.value = false;
+});
+useEventListener(window, 'mousemove', (e: MouseEvent) => {
+  if (dragging.value && e.buttons === 0) dragging.value = false;
+});
+
+// The band unmounts when locked, so its @mouseleave never fires — reset
+// explicitly so the shared state (and the clock) don't get stuck "active".
+watch(locked, (isLocked) => {
+  if (isLocked) {
+    hovered.value = false;
+    dragging.value = false;
+  }
+});
+onBeforeUnmount(() => {
+  hovered.value = false;
+  dragging.value = false;
+});
+
+// Explicit @mousedown rather than data-tauri-drag-region, which is flaky on
+// decorations:false + transparent:true windows.
 async function startDrag(event: MouseEvent): Promise<void> {
-  if (!props.isTauri) return;
+  if (!isTauri) return;
   if (event.button !== 0) return;
+  dragging.value = true;
   const { getCurrentWindow } = await import('@tauri-apps/api/window');
   await getCurrentWindow().startDragging();
 }
+
+// Right-click the map name → quick map switcher. Overlay always; browser only
+// on a wide enough viewport (phones have no right-click, skip them).
+const mapMenu = ref<InstanceType<typeof MapSwitchMenu> | null>(null);
+const wideEnough = useMediaQuery('(min-width: 640px)');
+function openMapMenu(event: MouseEvent): void {
+  if (!isTauri && !wideEnough.value) return;
+  mapMenu.value?.open(event.clientX, event.clientY);
+}
 </script>
 
 <template>
-  <div class="absolute top-3 right-3 z-[1000] flex items-center gap-2">
-    <!-- Unlocked: full pill with status dot + map name, also the drag handle. -->
-    <span
-      v-if="!overlayClickThrough"
-      class="inline-flex items-center gap-2 rounded-md bg-surface-800/70 px-3 py-1 text-sm font-medium text-surface-0 backdrop-blur select-none"
-      :class="isTauri ? 'cursor-grab active:cursor-grabbing' : 'pointer-events-none'"
-      @mousedown="startDrag"
+  <!-- OVERLAY (Tauri/preview), unlocked: a full-width top band that is both the
+       hover trigger and the drag region (grabbable anywhere, even when the
+       window is dragged mostly past a screen edge). Idle, only a small airy
+       grabber nub shows; hovering/dragging reveals two SEPARATE, never-
+       overlapping zones — a drag pill (left, flex-1) and the control cluster
+       (right, auto-width) — as flex siblings, so they can't collide. The pill
+       is visual only; the band owns the drag. -->
+  <div
+    v-if="tauriChrome && showControls"
+    class="sa-pt absolute top-0 right-0 left-0 z-[1000] flex h-12 cursor-grab items-start px-2 active:cursor-grabbing"
+    @mousedown="startDrag"
+    @mouseenter="hovered = true"
+    @mouseleave="hovered = false"
+    @contextmenu.prevent="openMapMenu"
+  >
+    <!-- Idle grabber nub (centred), cross-fades out when the bar is active. -->
+    <div
+      class="pointer-events-none absolute top-1.5 left-1/2 h-1.5 w-12 -translate-x-1/2 rounded-full bg-surface-500/70 shadow-md transition-opacity duration-200"
+      :class="dragBarActive ? 'opacity-0' : 'opacity-100'"
+      aria-hidden="true"
+    />
+
+    <!-- Revealed chrome: drag pill + controls, flex siblings (no overlap). -->
+    <div
+      class="flex h-10 w-full items-center gap-2 transition-all duration-200 ease-out"
+      :class="
+        dragBarActive ? 'translate-y-0 opacity-100' : 'pointer-events-none -translate-y-1 opacity-0'
+      "
     >
-      <i
-        :class="['text-[10px] pointer-events-none', statusIconClass]"
-        :title="'ws: ' + status"
-        aria-hidden="true"
-      />
-      <span class="pointer-events-none">{{ mapDisplayName }}</span>
-      <span class="sr-only" aria-live="polite">Connection: {{ status }}</span>
-    </span>
-    <!-- Locked overlay: collapse the pill to a single status dot. Map name
-         is redundant once the player has set up the overlay; only the
-         connection state is worth pixel-budget when the window is otherwise
-         frozen. -->
+      <!-- Drag pill: visual only; mousedown falls through to the band. -->
+      <div
+        :title="t('overlay.move')"
+        :aria-label="t('overlay.move')"
+        class="pointer-events-none flex h-10 min-w-0 flex-1 items-center gap-2 overflow-hidden rounded-2xl bg-surface-800/85 px-4 text-surface-0 ring-1 ring-white/10 backdrop-blur select-none"
+      >
+        <i class="pi pi-arrows-alt shrink-0 text-xs opacity-90" aria-hidden="true" />
+        <!-- Name lives in the always-visible clock+location chip now; the pill is
+             just the drag handle. -->
+        <span class="truncate text-sm font-medium opacity-80">{{ t('overlay.move') }}</span>
+      </div>
+
+      <!-- Controls: own pointer events, never start a drag. -->
+      <div class="flex shrink-0 items-center gap-2" @mousedown.stop>
+        <span
+          class="inline-flex h-8 w-8 items-center justify-center rounded-full bg-surface-800/85 ring-1 ring-white/10 backdrop-blur"
+          :title="'ws: ' + status"
+        >
+          <i :class="['text-[10px]', statusIconClass]" aria-hidden="true" />
+          <span class="sr-only" aria-live="polite">Connection: {{ status }}</span>
+        </span>
+        <SettingsPanel />
+        <Button
+          rounded
+          severity="secondary"
+          class="!bg-surface-800/85 hover:!bg-red-900 !border-surface-700 backdrop-blur"
+          :aria-label="t('close')"
+          @click="$emit('close')"
+        >
+          <template #icon>
+            <i class="pi pi-times text-sm" />
+          </template>
+        </Button>
+      </div>
+    </div>
+  </div>
+
+  <!-- OVERLAY locked: just the connection dot — no interactive chrome. -->
+  <div v-else-if="tauriChrome" class="sa-top sa-right absolute z-[1000]">
     <span
-      v-else
       class="inline-flex h-6 w-6 items-center justify-center rounded-full bg-surface-800/70 backdrop-blur pointer-events-none"
       :title="'ws: ' + status"
     >
       <i :class="['text-[10px]', statusIconClass]" aria-hidden="true" />
       <span class="sr-only" aria-live="polite">Connection: {{ status }}</span>
     </span>
-    <SettingsPanel v-if="!overlayClickThrough" />
-    <Button
-      v-if="isTauri && !overlayClickThrough"
-      rounded
-      severity="secondary"
-      class="!bg-surface-800/80 hover:!bg-red-900 !border-surface-700 backdrop-blur"
-      aria-label="Close"
-      @click="$emit('close')"
-    >
-      <template #icon>
-        <i class="pi pi-times text-sm" />
-      </template>
-    </Button>
   </div>
+
+  <!-- BROWSER: connection status + map name now live in the always-visible
+       clock chip (top-left), and the fullscreen/PWA helper moved to the Display
+       settings section — so the top-right cluster is just the gear, which keeps
+       the bar from overflowing on a 320px phone. -->
+  <div v-else class="sa-top sa-right absolute z-[1000] flex items-center gap-2">
+    <SettingsPanel />
+  </div>
+
+  <MapSwitchMenu ref="mapMenu" />
 </template>
diff --git a/apps/client/src/features/overlay/components/OverlayLockIndicator.vue b/apps/client/src/features/overlay/components/OverlayLockIndicator.vue
index 5ddb73f..495196b 100644
--- a/apps/client/src/features/overlay/components/OverlayLockIndicator.vue
+++ b/apps/client/src/features/overlay/components/OverlayLockIndicator.vue
@@ -1,27 +1,27 @@
 <script setup lang="ts">
 import { formatHotkeyParts } from '@/features/hotkeys/lib/hotkey';
+import { useOverlayLock } from '../composables/useOverlayLock';
 
 interface Props {
   lockHotkey: string;
-  overlayClickThrough: boolean;
 }
 
 const props = defineProps<Props>();
-defineEmits<{ lock: [] }>();
+const { locked, lock } = useOverlayLock();
 
 const lockHotkeyParts = computed(() => formatHotkeyParts(props.lockHotkey));
 
 // When click-through is on the lock button itself isn't clickable, so screen
 // readers need the keyboard escape route spelled out in the label.
 const lockAriaLabel = computed(() =>
-  props.overlayClickThrough
+  locked.value
     ? `Locked — press ${lockHotkeyParts.value.join(' + ')} to unlock`
     : 'Lock interaction',
 );
 </script>
 
 <template>
-  <div class="absolute bottom-3 right-3 z-[1000] flex items-center gap-2">
+  <div class="sa-bottom sa-right absolute z-[1000] flex items-center gap-2">
     <span
       class="pointer-events-none inline-flex items-center gap-1 rounded-md bg-surface-800/70 px-2 py-1 text-[10px] font-semibold tracking-wider backdrop-blur"
     >
@@ -34,13 +34,13 @@ const lockAriaLabel = computed(() =>
     </span>
     <Button
       rounded
-      :severity="overlayClickThrough ? 'primary' : 'secondary'"
+      :severity="locked ? 'primary' : 'secondary'"
       class="!bg-surface-800/80 hover:!bg-surface-800 !border-surface-700 backdrop-blur"
       :aria-label="lockAriaLabel"
-      @click="$emit('lock')"
+      @click="lock"
     >
       <template #icon>
-        <i :class="overlayClickThrough ? 'pi pi-lock' : 'pi pi-lock-open'" />
+        <i :class="locked ? 'pi pi-lock' : 'pi pi-lock-open'" />
       </template>
     </Button>
   </div>
diff --git a/apps/client/src/features/overlay/composables/useCloseConfirm.ts b/apps/client/src/features/overlay/composables/useCloseConfirm.ts
index eab1a7b..f3d46ae 100644
--- a/apps/client/src/features/overlay/composables/useCloseConfirm.ts
+++ b/apps/client/src/features/overlay/composables/useCloseConfirm.ts
@@ -1,18 +1,46 @@
 import { useConfirm } from 'primevue/useconfirm';
 import { useTauriOverlay } from './useTauriOverlay';
+import { useOverlayStore } from '@/features/overlay/store';
 
 /**
- * Returns a `confirmClose()` function that pops a PrimeVue confirm dialog
- * and, on accept, closes the Tauri window. No-op in browser context (the
- * close button is hidden there anyway).
+ * Returns the overlay ✕-button handler. With "minimize to tray" enabled it
+ * hides the window to the system tray (reversible — restore from the tray's
+ * Show item), so no confirm is needed. Otherwise it pops a confirm dialog and
+ * quits on accept. No-op in browser context (the ✕ is hidden there anyway).
  */
 export function useCloseConfirm(): () => void {
   const confirm = useConfirm();
   const { t } = useI18n();
   const { isTauri } = useTauriOverlay();
+  const { minimizeToTray, trayHintShown } = storeToRefs(useOverlayStore());
 
-  return function confirmClose(): void {
+  return function onCloseRequested(): void {
     if (!isTauri) return;
+
+    if (minimizeToTray.value) {
+      void (async () => {
+        const { getCurrentWindow } = await import('@tauri-apps/api/window');
+        await getCurrentWindow().hide();
+        // First time only: the window is now hidden, so an in-app toast can't
+        // be seen — fire a native OS notification telling the user it's still
+        // running in the tray, then remember we've said it.
+        if (!trayHintShown.value) {
+          trayHintShown.value = true;
+          try {
+            const { invoke } = await import('@tauri-apps/api/core');
+            await invoke('notify_tray_hint', {
+              title: t('trayHint.title'),
+              body: t('trayHint.body'),
+            });
+          } catch (err) {
+            // eslint-disable-next-line no-console
+            console.error('[tray] hint notification failed:', err);
+          }
+        }
+      })();
+      return;
+    }
+
     confirm.require({
       message: t('closeConfirm.message'),
       header: t('closeConfirm.title'),
diff --git a/apps/client/src/features/overlay/composables/useOverlayBootstrap.ts b/apps/client/src/features/overlay/composables/useOverlayBootstrap.ts
index 139dd11..c081508 100644
--- a/apps/client/src/features/overlay/composables/useOverlayBootstrap.ts
+++ b/apps/client/src/features/overlay/composables/useOverlayBootstrap.ts
@@ -46,22 +46,19 @@ export function useOverlayBootstrap(overlayClickThrough: Ref<boolean>): void {
   watch(overlayClickThrough, (locked) => void overlay.setClickThrough(locked));
   document.documentElement.classList.add('overlay-window');
 
-  // `overlay-unlocked` class drives the visible window border (see styles.css).
-  // The locked state never shows the border — the lock indicator alone says
-  // "can't interact", and the border would be wasted ink. Sync initially +
-  // on every flip so the visual matches the actual interaction mode.
-  function syncUnlockedClass(locked: boolean): void {
-    document.documentElement.classList.toggle('overlay-unlocked', !locked);
+  // Locking pins the window on top regardless of the user's always-on-top
+  // setting, so the overlay stays visible "out of raid"; unlocking restores
+  // their choice. Effective = user choice OR locked.
+  function applyAlwaysOnTop(): void {
+    void overlay.setAlwaysOnTop(alwaysOnTop.value || overlayClickThrough.value);
   }
-  syncUnlockedClass(overlayClickThrough.value);
-  watch(overlayClickThrough, syncUnlockedClass);
 
   // Replay persisted values to the native window before the user interacts
   // with anything. Same calls fire on each subsequent store change.
-  void overlay.setAlwaysOnTop(alwaysOnTop.value);
+  applyAlwaysOnTop();
   void overlay.setOpacity(opacity.value);
   void overlay.setZoom(Number(zoom.value) / 100);
-  watch(alwaysOnTop, (v) => void overlay.setAlwaysOnTop(v));
+  watch([alwaysOnTop, overlayClickThrough], applyAlwaysOnTop);
   watch(opacity, (v) => void overlay.setOpacity(v));
   watch(zoom, (v) => void overlay.setZoom(Number(v) / 100));
 }
diff --git a/apps/client/src/features/overlay/composables/useOverlayHeaderActive.ts b/apps/client/src/features/overlay/composables/useOverlayHeaderActive.ts
new file mode 100644
index 0000000..eb0d3da
--- /dev/null
+++ b/apps/client/src/features/overlay/composables/useOverlayHeaderActive.ts
@@ -0,0 +1,18 @@
+/**
+ * Shared (app-singleton) state for the overlay's top header band, so sibling
+ * chrome — e.g. the Tarkov clock — can slide out of the way when the band
+ * expands on hover/drag. Module-level refs: there is only ever one overlay
+ * window. OverlayHeader owns the writes (and resets them when locked/unmounted);
+ * everyone else reads `active`.
+ */
+const hovered = ref(false);
+const dragging = ref(false);
+const active = computed(() => hovered.value || dragging.value);
+
+export function useOverlayHeaderActive(): {
+  hovered: Ref<boolean>;
+  dragging: Ref<boolean>;
+  active: ComputedRef<boolean>;
+} {
+  return { hovered, dragging, active };
+}
diff --git a/apps/client/src/features/overlay/composables/useOverlayLock.ts b/apps/client/src/features/overlay/composables/useOverlayLock.ts
new file mode 100644
index 0000000..d3abf3f
--- /dev/null
+++ b/apps/client/src/features/overlay/composables/useOverlayLock.ts
@@ -0,0 +1,31 @@
+import { computed, type ComputedRef } from 'vue';
+import { useOverlayStore } from '../store';
+
+/**
+ * Single source of truth for the overlay's click-through lock policy:
+ * **controls hide, glanceable read-outs stay.** Every piece of chrome reads its
+ * lock-derived state from here instead of re-deriving `!clickThrough` itself, so
+ * the policy has ONE definition as more chrome is added.
+ *
+ * Read-only derived state + the `lock()` action (the lock button). Unlock is
+ * hotkey-only by design — see `App.vue`'s global shortcut.
+ */
+export interface OverlayLock {
+  /** Click-through is on; the overlay can't be clicked. */
+  locked: ComputedRef<boolean>;
+  /** Show interactive chrome (rail, top-band controls, border). Hidden on lock. */
+  showControls: ComputedRef<boolean>;
+  /** Engage the lock. */
+  lock: () => void;
+}
+
+export function useOverlayLock(): OverlayLock {
+  const { clickThrough } = storeToRefs(useOverlayStore());
+  return {
+    locked: computed(() => clickThrough.value),
+    showControls: computed(() => !clickThrough.value),
+    lock: () => {
+      clickThrough.value = true;
+    },
+  };
+}
diff --git a/apps/client/src/features/overlay/composables/useTrayIcon.ts b/apps/client/src/features/overlay/composables/useTrayIcon.ts
index 0586bb6..58aead6 100644
--- a/apps/client/src/features/overlay/composables/useTrayIcon.ts
+++ b/apps/client/src/features/overlay/composables/useTrayIcon.ts
@@ -1,59 +1,143 @@
-import type { TrayIcon } from '@tauri-apps/api/tray';
-import type { Menu } from '@tauri-apps/api/menu';
+import type { TrayIcon, TrayIconEvent } from '@tauri-apps/api/tray';
+import type { Menu, CheckMenuItem } from '@tauri-apps/api/menu';
 import { useI18nStore } from '@/features/i18n/store';
+import { useOverlayStore } from '@/features/overlay/store';
+import { useMapSettingsStore } from '@/features/map/store';
 
 type TrayHandle = Awaited<ReturnType<typeof TrayIcon.new>>;
-type TrayMenu = Awaited<ReturnType<typeof Menu.new>>;
 
 const TRAY_ID = 'tarkov-checker-tray';
 
+async function showWindow(): Promise<void> {
+  const { getCurrentWindow } = await import('@tauri-apps/api/window');
+  const win = getCurrentWindow();
+  await win.show();
+  await win.unminimize();
+  await win.setFocus();
+}
+
 /**
  * Owns the Tauri system-tray icon lifecycle: creates the icon on mount,
- * rebuilds the menu when the UI language changes, and removes the icon on
- * unmount. No-op in browser context.
+ * rebuilds the menu when the UI language changes, keeps the checkmark items in
+ * sync with their stores, and removes the icon on unmount. No-op in browser
+ * context.
+ *
+ * The tray is the only control surface reachable while the game is fullscreen
+ * (the overlay can be hidden or click-through-locked behind it), so the menu
+ * leans on actions that matter mid-game: unlock, restore, the always-on-top /
+ * player-follow toggles, and the LAN-share shortcuts. Left-click restores the
+ * window (Windows convention); right-click opens the menu. Since ✕ now parks
+ * the overlay in the tray (see overlay store `minimizeToTray`), "Quit" here is
+ * the canonical way to actually exit.
  */
 export function useTrayIcon(isTauri: boolean, overlayClickThrough: Ref<boolean>): void {
   if (!isTauri) return;
 
   const { t } = useI18n();
   const { apiLang } = storeToRefs(useI18nStore());
+  const { alwaysOnTop, pairingModalOpen } = storeToRefs(useOverlayStore());
+  const { playerFollow } = storeToRefs(useMapSettingsStore());
+
   let trayRef: TrayHandle | null = null;
+  // Live references to the check items so external state changes (hotkey,
+  // settings drawer, quick menu) can re-sync their checkmarks without
+  // rebuilding the whole menu.
+  let lockItem: CheckMenuItem | null = null;
+  let aotItem: CheckMenuItem | null = null;
+  let followItem: CheckMenuItem | null = null;
+
+  async function copyLanUrl(): Promise<void> {
+    try {
+      const { invoke } = await import('@tauri-apps/api/core');
+      await invoke('copy_lan_url');
+    } catch (err) {
+      // eslint-disable-next-line no-console
+      console.error('[tray] copy LAN URL failed:', err);
+    }
+  }
+
+  async function buildTrayMenu(): Promise<Menu> {
+    const { Menu, MenuItem, CheckMenuItem, PredefinedMenuItem } =
+      await import('@tauri-apps/api/menu');
+    const separator = () => PredefinedMenuItem.new({ item: 'Separator' });
+
+    lockItem = await CheckMenuItem.new({
+      id: 'toggle-lock',
+      text: t('tray.lock'),
+      checked: overlayClickThrough.value,
+      action: () => {
+        overlayClickThrough.value = !overlayClickThrough.value;
+      },
+    });
+    const showItem = await MenuItem.new({
+      id: 'show',
+      text: t('tray.showWindow'),
+      action: () => void showWindow(),
+    });
+    aotItem = await CheckMenuItem.new({
+      id: 'always-on-top',
+      text: t('tray.alwaysOnTop'),
+      checked: alwaysOnTop.value,
+      action: () => {
+        alwaysOnTop.value = !alwaysOnTop.value;
+      },
+    });
+    followItem = await CheckMenuItem.new({
+      id: 'player-follow',
+      text: t('tray.playerFollow'),
+      checked: playerFollow.value === 'on',
+      action: () => {
+        playerFollow.value = playerFollow.value === 'on' ? 'off' : 'on';
+      },
+    });
+    const pairItem = await MenuItem.new({
+      id: 'pair-phone',
+      text: t('tray.pairPhone'),
+      action: () => {
+        void showWindow();
+        pairingModalOpen.value = true;
+      },
+    });
+    const copyItem = await MenuItem.new({
+      id: 'copy-url',
+      text: t('tray.copyUrl'),
+      action: () => void copyLanUrl(),
+    });
+    const quitItem = await MenuItem.new({
+      id: 'quit',
+      text: t('tray.quit'),
+      action: () =>
+        void (async () => {
+          const { getCurrentWindow } = await import('@tauri-apps/api/window');
+          await getCurrentWindow().close();
+        })(),
+    });
 
-  async function buildTrayMenu(): Promise<TrayMenu> {
-    const [{ Menu }, { getCurrentWindow }] = await Promise.all([
-      import('@tauri-apps/api/menu'),
-      import('@tauri-apps/api/window'),
-    ]);
     return Menu.new({
       items: [
-        {
-          id: 'toggle-lock',
-          text: t('tray.toggleLock'),
-          action: () => {
-            overlayClickThrough.value = !overlayClickThrough.value;
-          },
-        },
-        {
-          id: 'show',
-          text: t('tray.showWindow'),
-          action: async () => {
-            const win = getCurrentWindow();
-            await win.show();
-            await win.setFocus();
-          },
-        },
-        { item: 'Separator' },
-        {
-          id: 'quit',
-          text: t('tray.quit'),
-          action: async () => {
-            await getCurrentWindow().close();
-          },
-        },
+        lockItem,
+        await separator(),
+        showItem,
+        await separator(),
+        aotItem,
+        followItem,
+        await separator(),
+        pairItem,
+        copyItem,
+        await separator(),
+        quitItem,
       ],
     });
   }
 
+  // Left-click restores the overlay (Windows convention); the menu opens on
+  // right-click. `showMenuOnLeftClick: false` routes left clicks here instead.
+  function onTrayEvent(event: TrayIconEvent): void {
+    if (event.type === 'Click' && event.button === 'Left' && event.buttonState === 'Up') {
+      void showWindow();
+    }
+  }
+
   onMounted(async () => {
     try {
       const [{ TrayIcon }, { defaultWindowIcon }] = await Promise.all([
@@ -66,7 +150,8 @@ export function useTrayIcon(isTauri: boolean, overlayClickThrough: Ref<boolean>)
         icon: icon ?? undefined,
         menu: await buildTrayMenu(),
         tooltip: t('tray.tooltip'),
-        showMenuOnLeftClick: true,
+        showMenuOnLeftClick: false,
+        action: onTrayEvent,
       });
     } catch (err) {
       // eslint-disable-next-line no-console
@@ -74,6 +159,11 @@ export function useTrayIcon(isTauri: boolean, overlayClickThrough: Ref<boolean>)
     }
   });
 
+  // Keep checkmarks in sync when state is changed from anywhere else.
+  watch(overlayClickThrough, (v) => void lockItem?.setChecked(v));
+  watch(alwaysOnTop, (v) => void aotItem?.setChecked(v));
+  watch(playerFollow, (v) => void followItem?.setChecked(v === 'on'));
+
   watch(apiLang, async () => {
     if (!trayRef) return;
     try {
diff --git a/apps/client/src/features/overlay/settings.ts b/apps/client/src/features/overlay/settings.ts
index e1af2be..647e7fd 100644
--- a/apps/client/src/features/overlay/settings.ts
+++ b/apps/client/src/features/overlay/settings.ts
@@ -4,19 +4,19 @@ import PairingSection from '@/features/settings/sections/PairingSection.vue';
 
 registerSettingsSection({
   id: 'overlay',
-  group: 'main',
-  order: 50,
+  order: 10,
   visible: 'tauri',
+  titleKey: 'overlay.heading',
   component: OverlaySection,
 });
 
-// Pairing lives in system: it's a host-level action ("hand out QR to my
-// phone"), not a per-overlay preference. Tauri-only — pairing_qr is an
-// IPC command, and pairing yourself from a phone makes no sense.
+// Pairing is a host-level action ("hand out QR to my phone"), not a per-overlay
+// preference. Tauri-only — pairing_qr is an IPC command, and pairing yourself
+// from a phone makes no sense.
 registerSettingsSection({
   id: 'pairing',
-  group: 'system',
-  order: 30,
+  order: 50,
   visible: 'tauri',
+  titleKey: 'pairing.heading',
   component: PairingSection,
 });
diff --git a/apps/client/src/features/overlay/store.ts b/apps/client/src/features/overlay/store.ts
index 4b4acd5..89ab505 100644
--- a/apps/client/src/features/overlay/store.ts
+++ b/apps/client/src/features/overlay/store.ts
@@ -10,6 +10,18 @@ export const useOverlayStore = defineStore('overlay', () => {
   const mapOpacity = persistedRef('tc.overlay.mapOpacity', z.number().min(0).max(1), 1);
   const zoom = persistedRef('tc.overlay.zoom', overlayZoomSchema, '100' as OverlayZoom);
 
+  // When on, the ✕ button hides the window to the system tray (keeps running)
+  // instead of quitting; restore via the tray's "Show window", quit via the
+  // tray's "Quit". Default ON — closing parks the overlay in the tray rather
+  // than killing the session. Users who prefer ✕ = confirmed quit can flip it
+  // off in Settings.
+  const minimizeToTray = persistedRef('tc.overlay.minimizeToTray', z.boolean(), true);
+
+  // One-shot: tracks whether the "still running in the tray" notification has
+  // been shown. Set true after the first close-to-tray so the hint fires once,
+  // not on every ✕.
+  const trayHintShown = persistedRef('tc.overlay.trayHintShown', z.boolean(), false);
+
   // Session-only: booting into a locked overlay with a broken hotkey would be
   // unrecoverable, so the locked state is intentionally NOT persisted.
   const clickThrough = ref(false);
@@ -19,5 +31,14 @@ export const useOverlayStore = defineStore('overlay', () => {
   // persisted — pairing is per-action, never "remembered open".
   const pairingModalOpen = ref(false);
 
-  return { alwaysOnTop, opacity, mapOpacity, zoom, clickThrough, pairingModalOpen };
+  return {
+    alwaysOnTop,
+    opacity,
+    mapOpacity,
+    zoom,
+    minimizeToTray,
+    trayHintShown,
+    clickThrough,
+    pairingModalOpen,
+  };
 });
diff --git a/apps/client/src/features/server/api/hotkeys-api.ts b/apps/client/src/features/server/api/hotkeys-api.ts
new file mode 100644
index 0000000..b1f6560
--- /dev/null
+++ b/apps/client/src/features/server/api/hotkeys-api.ts
@@ -0,0 +1,42 @@
+import { hotkeyConfigSchema, type HotkeyConfig, type HotkeyPatch } from '@shared/hotkeys-api';
+import { callBackend } from './transport';
+
+const parseConfig = (d: unknown): HotkeyConfig => hotkeyConfigSchema.parse(d);
+
+/** GET the backend-owned hotkey combos (the source of truth). */
+export function fetchHotkeys(): Promise<HotkeyConfig> {
+  return callBackend({
+    tauri: { cmd: 'get_hotkeys' },
+    http: { method: 'GET', path: '/api/hotkeys' },
+    parse: parseConfig,
+  });
+}
+
+/** PUT a partial update; the backend (re)registers and returns the EFFECTIVE
+ * config — a field whose combo couldn't be claimed comes back reverted. */
+export function putHotkeys(patch: HotkeyPatch): Promise<HotkeyConfig> {
+  return callBackend({
+    tauri: { cmd: 'update_hotkeys', args: { patch } },
+    http: { method: 'PUT', path: '/api/hotkeys', body: patch },
+    parse: parseConfig,
+  });
+}
+
+/** Release the OS binds while the settings recorder captures a combo, so the
+ * keystroke reaches the page/webview instead of firing its action. */
+export function suspendHotkeys(): Promise<void> {
+  return callBackend({
+    tauri: { cmd: 'suspend_hotkeys' },
+    http: { method: 'POST', path: '/api/hotkeys/suspend' },
+    parse: () => undefined,
+  });
+}
+
+/** Re-claim the OS binds after the recorder finishes. */
+export function resumeHotkeys(): Promise<void> {
+  return callBackend({
+    tauri: { cmd: 'resume_hotkeys' },
+    http: { method: 'POST', path: '/api/hotkeys/resume' },
+    parse: () => undefined,
+  });
+}
diff --git a/apps/client/src/features/server/api/ipc-contract.ts b/apps/client/src/features/server/api/ipc-contract.ts
index 8c80aae..4412603 100644
--- a/apps/client/src/features/server/api/ipc-contract.ts
+++ b/apps/client/src/features/server/api/ipc-contract.ts
@@ -1,4 +1,5 @@
 import type { ServerConfigResponse, ServerConfigUpdate } from '@shared/config-api';
+import type { HotkeyConfig, HotkeyPatch } from '@shared/hotkeys-api';
 
 /**
  * The full set of Tauri IPC commands the Rust side exposes (see
@@ -19,6 +20,22 @@ export interface IpcContract {
     args: { patch: ServerConfigUpdate };
     result: ServerConfigResponse;
   };
+  get_hotkeys: {
+    args: undefined;
+    result: HotkeyConfig;
+  };
+  update_hotkeys: {
+    args: { patch: HotkeyPatch };
+    result: HotkeyConfig;
+  };
+  suspend_hotkeys: {
+    args: undefined;
+    result: void;
+  };
+  resume_hotkeys: {
+    args: undefined;
+    result: void;
+  };
 }
 
 export type IpcCommand = keyof IpcContract;
diff --git a/apps/client/src/features/server/api/transport.ts b/apps/client/src/features/server/api/transport.ts
index 7e1df29..3b92f0e 100644
--- a/apps/client/src/features/server/api/transport.ts
+++ b/apps/client/src/features/server/api/transport.ts
@@ -3,8 +3,9 @@
  * runs both inside the Tauri overlay and as a plain browser page:
  *
  * - In Tauri: invokes a named IPC command via `@tauri-apps/api/core`.
- * - In a plain browser: makes a same-origin HTTP call (Vite proxies /api to
- *   Fastify in dev; Fastify serves both the SPA and /api in prod).
+ * - In a plain browser: makes a same-origin HTTP call to the in-process Rust
+ *   helper (Vite proxies /api to it on :47474 in dev; in release the helper
+ *   serves both the embedded SPA and /api itself).
  *
  * The raw response is fed through `parse` (typically a zod schema's `.parse`)
  * so callers get a validated, typed result either way.
@@ -64,5 +65,7 @@ async function httpRequest<T>(http: HttpCall, parse: (data: unknown) => T): Prom
     const detail = typeof body === 'object' && body !== null && 'error' in body ? body.error : body;
     throw new Error(`${method} ${http.path} failed: HTTP ${r.status} — ${JSON.stringify(detail)}`);
   }
+  // 204 No Content (e.g. /api/hotkeys/suspend) has no body to parse.
+  if (r.status === 204) return parse(undefined);
   return parse(await r.json());
 }
diff --git a/apps/client/src/features/server/composables/useServerEvents.ts b/apps/client/src/features/server/composables/useServerEvents.ts
index f49464f..a6b9300 100644
--- a/apps/client/src/features/server/composables/useServerEvents.ts
+++ b/apps/client/src/features/server/composables/useServerEvents.ts
@@ -1,4 +1,4 @@
-import type { ServerMessage, ServerMessageType } from '@shared/ws-messages';
+import type { ServerMessage, ServerMessageType } from '@shared/sse-messages';
 
 type EventMap = {
   [K in ServerMessageType]: Extract<ServerMessage, { type: K }>;
diff --git a/apps/client/src/features/server/composables/useServerPaths.ts b/apps/client/src/features/server/composables/useServerPaths.ts
index bf1bf5f..901903c 100644
--- a/apps/client/src/features/server/composables/useServerPaths.ts
+++ b/apps/client/src/features/server/composables/useServerPaths.ts
@@ -24,6 +24,8 @@ export interface UseServerPaths {
   canSavePaths: ComputedRef<boolean>;
   savePaths: () => Promise<void>;
   statusIconClass: (slot: PathSlot) => string;
+  deleteScreenshots: Ref<boolean>;
+  setDeleteScreenshots: (v: boolean) => Promise<void>;
 }
 
 /**
@@ -73,6 +75,7 @@ export function useServerPaths(canEditPaths: Ref<boolean>): UseServerPaths {
   const pathsSaving = ref(false);
   const pathsError = ref<PathsError | null>(null);
   const pathsJustSaved = ref(false);
+  const deleteScreenshots = ref(false);
 
   const gameDirLocked = computed(() => serverConfig.value?.gameDir.source === 'env');
   const screenshotsDirLocked = computed(() => serverConfig.value?.screenshotsDir.source === 'env');
@@ -91,6 +94,7 @@ export function useServerPaths(canEditPaths: Ref<boolean>): UseServerPaths {
     serverConfig.value = cfg;
     gameDirInput.value = cfg.gameDir.value ?? '';
     screenshotsDirInput.value = cfg.screenshotsDir.value ?? '';
+    deleteScreenshots.value = cfg.deleteScreenshots;
   }
 
   async function loadPaths(): Promise<void> {
@@ -136,6 +140,26 @@ export function useServerPaths(canEditPaths: Ref<boolean>): UseServerPaths {
     }
   }
 
+  /**
+   * Immediate-save toggle (no "Save" button — it's a switch). Optimistically
+   * flips the ref, PUTs just the flag, and reverts on failure. The backend
+   * enforces the actual deletion in the screenshot watcher.
+   */
+  async function setDeleteScreenshots(v: boolean): Promise<void> {
+    const prev = deleteScreenshots.value;
+    if (prev === v) return;
+    deleteScreenshots.value = v;
+    pathsError.value = null;
+    try {
+      const cfg = await putServerConfig({ deleteScreenshots: v });
+      cachedConfig = cfg;
+      applyConfig(cfg);
+    } catch (err) {
+      deleteScreenshots.value = prev;
+      pathsError.value = toPathsError(err);
+    }
+  }
+
   function statusIconClass(slot: PathSlot): string {
     const item = serverConfig.value?.[slot];
     if (!item) return 'pi pi-circle text-surface-500';
@@ -161,5 +185,7 @@ export function useServerPaths(canEditPaths: Ref<boolean>): UseServerPaths {
     canSavePaths,
     savePaths,
     statusIconClass,
+    deleteScreenshots,
+    setDeleteScreenshots,
   };
 }
diff --git a/apps/client/src/features/server/composables/useServerStream.ts b/apps/client/src/features/server/composables/useServerStream.ts
index 756c242..b5771ed 100644
--- a/apps/client/src/features/server/composables/useServerStream.ts
+++ b/apps/client/src/features/server/composables/useServerStream.ts
@@ -1,4 +1,4 @@
-import { serverMessage } from '@shared/ws-messages';
+import { serverMessage } from '@shared/sse-messages';
 import { dispatchServerEvent } from './useServerEvents';
 
 export type StreamStatus = 'connecting' | 'open' | 'closed';
diff --git a/apps/client/src/features/server/composables/useServerTransport.ts b/apps/client/src/features/server/composables/useServerTransport.ts
index 6410496..122bcb9 100644
--- a/apps/client/src/features/server/composables/useServerTransport.ts
+++ b/apps/client/src/features/server/composables/useServerTransport.ts
@@ -1,9 +1,11 @@
 import {
+  commandMessage,
   mapChangeMessage,
   positionMessage,
+  type CommandMessage,
   type MapChangeMessage,
   type PositionMessage,
-} from '@shared/ws-messages';
+} from '@shared/sse-messages';
 import { isTauri } from '@/shared/tauri';
 import { useServerStream } from './useServerStream';
 import { dispatchServerEvent } from './useServerEvents';
@@ -19,6 +21,7 @@ export interface UseServerTransport {
 // message minus its literal `type` field.
 type PositionPayload = Omit<PositionMessage, 'type'>;
 type MapChangePayload = Omit<MapChangeMessage, 'type'>;
+type CommandPayload = Omit<CommandMessage, 'type'>;
 
 /**
  * Single entry point for "server-pushed" messages — mount once at the app
@@ -58,6 +61,15 @@ export function useServerTransport(streamUrl: string): UseServerTransport {
         if (parsed.success) dispatchServerEvent(parsed.data);
       }),
     );
+    // Backend-owned global hotkey presses. The browser/SSE path gets these
+    // for free via the discriminated union in `useServerStream`; the Tauri
+    // path needs its own listener because Rust emits via `app.emit`.
+    unlistens.push(
+      await listen<CommandPayload>('command', (event) => {
+        const parsed = commandMessage.safeParse({ type: 'command', ...event.payload });
+        if (parsed.success) dispatchServerEvent(parsed.data);
+      }),
+    );
     status.value = 'open';
   });
 
diff --git a/apps/client/src/features/server/settings.ts b/apps/client/src/features/server/settings.ts
index effe9af..5e66c19 100644
--- a/apps/client/src/features/server/settings.ts
+++ b/apps/client/src/features/server/settings.ts
@@ -3,8 +3,10 @@ import PathsSection from '@/features/settings/sections/PathsSection.vue';
 
 registerSettingsSection({
   id: 'paths',
-  group: 'system',
-  order: 20,
-  visible: 'desktop-or-tauri',
+  order: 40,
+  // 'always': phones get the read-only view (PathsSection's canEditPaths) —
+  // path status is useful for diagnostics, editing stays desktop/Tauri-only.
+  visible: 'always',
+  titleKey: 'paths.heading',
   component: PathsSection,
 });
diff --git a/apps/client/src/features/settings/SettingsPanel.vue b/apps/client/src/features/settings/SettingsPanel.vue
index 66fa41d..4f3f065 100644
--- a/apps/client/src/features/settings/SettingsPanel.vue
+++ b/apps/client/src/features/settings/SettingsPanel.vue
@@ -1,11 +1,22 @@
 <script setup lang="ts">
+import { z } from 'zod';
 import { useSettingsSections } from './registry';
+import { persistedRef } from '@/shared/persisted-store';
 
 const { t } = useI18n();
-const mainSections = useSettingsSections('main');
-const systemSections = useSettingsSections('system');
+const systemSections = useSettingsSections();
 const open = ref(false);
 const isDesktop = useMediaQuery('(min-width: 640px)');
+
+// System/app settings only. Map layers moved out of the drawer onto the on-map
+// LayerRail; the gear now holds the rare config (overlay/hotkeys/language/
+// paths/pairing). Desktop opens every section; the overlay/phone start
+// collapsed to keep the sheet short. Snapshotted once, then user choices persist.
+const openSections = persistedRef(
+  'tc.settings.open',
+  z.array(z.string()),
+  isDesktop.value ? systemSections.value.map((s) => s.id) : [],
+);
 </script>
 
 <template>
@@ -37,24 +48,24 @@ const isDesktop = useMediaQuery('(min-width: 640px)');
     </template>
   </Button>
 
+  <!-- System/app config only — map layers live on the on-map LayerRail now.
+       Non-modal so the map stays live behind it; bottom-sheet on the overlay/
+       phone, right-side panel on desktop. -->
   <Drawer
     v-model:visible="open"
-    :position="isDesktop ? 'right' : 'full'"
+    :modal="false"
+    :dismissable="false"
+    :position="isDesktop ? 'right' : 'bottom'"
     :header="t('settings')"
-    :class="isDesktop ? '!w-[26rem]' : ''"
+    :class="isDesktop ? '!w-[26rem]' : '!h-auto !max-h-[85svh] !rounded-t-2xl'"
   >
-    <div class="space-y-4">
-      <component :is="sec.component" v-for="sec in mainSections" :key="sec.id" />
-
-      <div v-if="systemSections.length" class="pt-2 mt-2 border-t border-surface-700">
-        <p class="mb-3 text-[10px] font-semibold uppercase tracking-wider opacity-70">
-          {{ t('systemSection') }}
-        </p>
-
-        <div class="space-y-4">
-          <component :is="sec.component" v-for="sec in systemSections" :key="sec.id" />
-        </div>
-      </div>
-    </div>
+    <Accordion v-model:value="openSections" multiple>
+      <AccordionPanel v-for="sec in systemSections" :key="sec.id" :value="sec.id">
+        <AccordionHeader>{{ t(sec.titleKey) }}</AccordionHeader>
+        <AccordionContent>
+          <component :is="sec.component" />
+        </AccordionContent>
+      </AccordionPanel>
+    </Accordion>
   </Drawer>
 </template>
diff --git a/apps/client/src/features/settings/registry.ts b/apps/client/src/features/settings/registry.ts
index 41356dd..4d77613 100644
--- a/apps/client/src/features/settings/registry.ts
+++ b/apps/client/src/features/settings/registry.ts
@@ -2,25 +2,22 @@ import { computed, shallowReactive, type ComputedRef, type Component } from 'vue
 import { useMediaQuery } from '@vueuse/core';
 import { isTauri } from '@/shared/tauri';
 
-export type SectionGroup = 'main' | 'system';
-export type SectionVisibility = 'always' | 'tauri' | 'desktop-or-tauri';
+export type SectionVisibility = 'always' | 'tauri' | 'desktop-or-tauri' | 'browser';
 
 export interface SettingsSection {
   id: string;
-  group: SectionGroup;
-  /** Ascending; use multiples of 10 so future insertions fit between existing entries.
-   * main: 10 map, 20 extracts, 30 player, 40 airdrop, 50 overlay, 60 hotkeys
-   * system: 10 language, 20 paths, 30 pairing */
+  /** Ascending; use multiples of 10 so future insertions fit between entries. */
   order: number;
+  /** i18n key for the accordion header label (the section title). */
+  titleKey: string;
   visible?: SectionVisibility;
-  /** Sync `Component` or `defineAsyncComponent(() => import('...'))` —
-   *  Vue resolves both. */
+  /** Sync `Component` or `defineAsyncComponent(() => import('...'))`. */
   component: Component;
 }
 
-// shallowReactive so `useSettingsSections`'s computed re-tracks on
-// registerSettingsSection during dev HMR (or any future late registration).
-// Plain Map mutations would otherwise go unnoticed by Vue's tracker.
+// System/app settings only (the gear drawer). Map layers self-describe their
+// own settings via the map-layer registry now — this registry no longer carries
+// any layer concept (no groups/subgroups).
 const registry = shallowReactive(new Map<string, SettingsSection>());
 
 // HMR-safe: replace existing entry instead of duplicating on hot-reload.
@@ -28,18 +25,19 @@ export function registerSettingsSection(s: SettingsSection): void {
   registry.set(s.id, s);
 }
 
-export function useSettingsSections(group: SectionGroup): ComputedRef<SettingsSection[]> {
+export function useSettingsSections(): ComputedRef<SettingsSection[]> {
   const isDesktop = useMediaQuery('(min-width: 640px)');
 
   return computed(() => {
     const visible = (v: SectionVisibility = 'always'): boolean => {
       if (v === 'always') return true;
       if (v === 'tauri') return isTauri;
+      if (v === 'browser') return !isTauri;
       return isTauri || isDesktop.value;
     };
 
     return [...registry.values()]
-      .filter((s) => s.group === group && visible(s.visible))
+      .filter((s) => visible(s.visible))
       .sort((a, b) => a.order - b.order);
   });
 }
diff --git a/apps/client/src/features/settings/sections/AirdropSection.vue b/apps/client/src/features/settings/sections/AirdropSection.vue
index 114b03b..b788ea8 100644
--- a/apps/client/src/features/settings/sections/AirdropSection.vue
+++ b/apps/client/src/features/settings/sections/AirdropSection.vue
@@ -6,21 +6,19 @@ const { t } = useI18n();
 </script>
 
 <template>
-  <Fieldset :legend="t('airdrop.settingsHeading')">
-    <div>
-      <div class="mb-1.5 flex items-center justify-between gap-3">
-        <label class="text-xs opacity-70" for="airdrop-radius">{{ t('airdrop.radius') }}</label>
-        <span class="text-xs tabular-nums opacity-70">{{ dropMarkerRadius }}m</span>
-      </div>
-      <Slider
-        v-model="dropMarkerRadius"
-        :min="DROP_MARKER_RADIUS_RANGE.min"
-        :max="DROP_MARKER_RADIUS_RANGE.max"
-        :step="1"
-        input-id="airdrop-radius"
-        class="w-full"
-      />
-      <p class="mt-1.5 text-[10px] leading-relaxed opacity-70">{{ t('airdrop.radiusHint') }}</p>
+  <div>
+    <div class="mb-1.5 flex items-center justify-between gap-3">
+      <label class="text-xs opacity-70" for="airdrop-radius">{{ t('airdrop.radius') }}</label>
+      <span class="text-xs tabular-nums opacity-70">{{ dropMarkerRadius }}m</span>
     </div>
-  </Fieldset>
+    <Slider
+      v-model="dropMarkerRadius"
+      :min="DROP_MARKER_RADIUS_RANGE.min"
+      :max="DROP_MARKER_RADIUS_RANGE.max"
+      :step="1"
+      input-id="airdrop-radius"
+      class="w-full"
+    />
+    <p class="mt-1.5 text-[10px] leading-relaxed opacity-70">{{ t('airdrop.radiusHint') }}</p>
+  </div>
 </template>
diff --git a/apps/client/src/features/settings/sections/ExtractsSection.vue b/apps/client/src/features/settings/sections/ExtractsSection.vue
index 0f74df2..188e7c0 100644
--- a/apps/client/src/features/settings/sections/ExtractsSection.vue
+++ b/apps/client/src/features/settings/sections/ExtractsSection.vue
@@ -2,7 +2,8 @@
 import { FACTION_COLORS } from '@shared/maps';
 import { useMapSettingsStore, type ExtractFactionFilter } from '@/features/map/store';
 
-const { extractFactions, extractLabelMode, extractLabelSize } = storeToRefs(useMapSettingsStore());
+const { extractFactions, extractLabelMode, extractLabelSize, edgeIndicators } =
+  storeToRefs(useMapSettingsStore());
 const { t } = useI18n();
 
 const FACTION_OPTIONS: ReadonlyArray<{
@@ -27,7 +28,7 @@ const labelSizeOptions = computed(() => [
 </script>
 
 <template>
-  <Fieldset :legend="t('extracts')">
+  <div class="space-y-3">
     <div class="flex flex-col gap-1">
       <label
         v-for="opt in FACTION_OPTIONS"
@@ -40,7 +41,7 @@ const labelSizeOptions = computed(() => [
       </label>
     </div>
 
-    <div class="mt-3">
+    <div>
       <p class="mb-1.5 text-xs opacity-60">{{ t('labels') }}</p>
       <SelectButton
         v-model="extractLabelMode"
@@ -49,12 +50,12 @@ const labelSizeOptions = computed(() => [
         option-value="value"
         :allow-empty="false"
         size="small"
-        class="w-full"
+        fluid
       />
       <p class="mt-1.5 text-[10px] leading-relaxed opacity-70">{{ t('labelHint') }}</p>
     </div>
 
-    <div class="mt-3">
+    <div>
       <p class="mb-1.5 text-xs opacity-60">{{ t('labelSize') }}</p>
       <SelectButton
         v-model="extractLabelSize"
@@ -63,8 +64,16 @@ const labelSizeOptions = computed(() => [
         option-value="value"
         :allow-empty="false"
         size="small"
-        class="w-full"
+        fluid
       />
     </div>
-  </Fieldset>
+
+    <div>
+      <div class="flex items-center justify-between gap-3">
+        <label class="text-sm" for="extract-edge-indicators">{{ t('edgeIndicators') }}</label>
+        <ToggleSwitch v-model="edgeIndicators" input-id="extract-edge-indicators" />
+      </div>
+      <p class="mt-1.5 text-[10px] leading-relaxed opacity-70">{{ t('edgeIndicatorsHint') }}</p>
+    </div>
+  </div>
 </template>
diff --git a/apps/client/src/features/settings/sections/HotkeysSection.vue b/apps/client/src/features/settings/sections/HotkeysSection.vue
index eb853a8..2084616 100644
--- a/apps/client/src/features/settings/sections/HotkeysSection.vue
+++ b/apps/client/src/features/settings/sections/HotkeysSection.vue
@@ -1,22 +1,97 @@
 <script setup lang="ts">
 import HotkeyRecorder from '@/features/hotkeys/components/HotkeyRecorder.vue';
 import { useHotkeysStore } from '@/features/hotkeys/store';
+import { isTauri } from '@/shared/tauri';
+import type { HotkeyConfig } from '@shared/hotkeys-api';
 
+const store = useHotkeysStore();
 const { lockHotkey, zoomInHotkey, zoomOutHotkey, floorUpHotkey, floorDownHotkey, airdropHotkey } =
-  storeToRefs(useHotkeysStore());
+  storeToRefs(store);
 const { t } = useI18n();
+
+// Combos are backend-owned and fire globally, but recording a new one needs a
+// physical keyboard (the recorder captures window keydown). So rows are editable
+// on the overlay + desktop browser, read-only on a phone — which just displays
+// the current binds and points at the overlay for rebinding.
+const isDesktop = useMediaQuery('(min-width: 640px)');
+const rebindable = computed(() => isTauri || isDesktop.value);
+
+// The five action combos are backend-owned: route a recorded combo through
+// `setAction` (PUT + effective-value snap-back) rather than writing the ref
+// directly. Lock stays a plain client-side persistedRef (v-model).
+function onAction(field: keyof HotkeyConfig, combo: string): void {
+  void store.setAction(field, combo);
+}
 </script>
 
 <template>
-  <Fieldset :legend="t('hotkeys.heading')">
-    <div class="space-y-3">
-      <HotkeyRecorder v-model="lockHotkey" :label="t('hotkeys.lock')" />
-      <HotkeyRecorder v-model="zoomInHotkey" :label="t('hotkeys.zoomIn')" />
-      <HotkeyRecorder v-model="zoomOutHotkey" :label="t('hotkeys.zoomOut')" />
-      <HotkeyRecorder v-model="floorUpHotkey" :label="t('hotkeys.floorUp')" />
-      <HotkeyRecorder v-model="floorDownHotkey" :label="t('hotkeys.floorDown')" />
-      <HotkeyRecorder v-model="airdropHotkey" :label="t('hotkeys.airdrop')" />
-      <p class="text-[10px] leading-relaxed opacity-70">{{ t('hotkeys.lockHint') }}</p>
+  <div class="space-y-3">
+    <!-- Phone: no keyboard to record, so the rows are read-only — explain where
+         to rebind. -->
+    <p v-if="!rebindable" class="text-[10px] leading-relaxed opacity-70">
+      {{ t('hotkeys.rebindHint') }}
+    </p>
+
+    <!-- Lock is overlay-only (no window to lock in a browser). -->
+    <HotkeyRecorder v-if="isTauri" v-model="lockHotkey" :label="t('hotkeys.lock')" />
+    <HotkeyRecorder
+      :model-value="zoomInHotkey"
+      :label="t('hotkeys.zoomIn')"
+      :readonly="!rebindable"
+      @update:model-value="onAction('zoomIn', $event)"
+    />
+    <HotkeyRecorder
+      :model-value="zoomOutHotkey"
+      :label="t('hotkeys.zoomOut')"
+      :readonly="!rebindable"
+      @update:model-value="onAction('zoomOut', $event)"
+    />
+    <HotkeyRecorder
+      :model-value="floorUpHotkey"
+      :label="t('hotkeys.floorUp')"
+      :readonly="!rebindable"
+      @update:model-value="onAction('floorUp', $event)"
+    />
+    <HotkeyRecorder
+      :model-value="floorDownHotkey"
+      :label="t('hotkeys.floorDown')"
+      :readonly="!rebindable"
+      @update:model-value="onAction('floorDown', $event)"
+    />
+
+    <!-- Read-only gesture: Alt + mouse wheel over the map steps floors. Listed
+         here for discoverability but not rebindable (lock icon in the button
+         slot instead of a recorder). Mouse-only, so hidden on phones. -->
+    <div v-if="rebindable">
+      <p class="mb-1 text-xs opacity-60">{{ t('hotkeys.floorWheel') }}</p>
+      <div class="flex items-center justify-between gap-2">
+        <div
+          class="bg-surface-900/60 inline-flex items-center gap-1 rounded-md px-2 py-1.5 text-[11px] font-semibold tracking-wider opacity-70"
+        >
+          <span class="border-surface-600 bg-surface-900 rounded border px-1.5 py-0.5 font-mono">
+            Alt
+          </span>
+          <span class="px-1 opacity-60">+</span>
+          <span class="border-surface-600 bg-surface-900 rounded border px-1.5 py-0.5 font-mono">
+            {{ t('hotkeys.scroll') }}
+          </span>
+        </div>
+        <i
+          v-tooltip.left="t('hotkeys.fixed')"
+          class="pi pi-lock shrink-0 text-xs opacity-40"
+          :aria-label="t('hotkeys.fixed')"
+        />
+      </div>
     </div>
-  </Fieldset>
+
+    <HotkeyRecorder
+      :model-value="airdropHotkey"
+      :label="t('hotkeys.airdrop')"
+      :readonly="!rebindable"
+      @update:model-value="onAction('airdrop', $event)"
+    />
+    <p v-if="isTauri" class="text-[10px] leading-relaxed opacity-70">
+      {{ t('hotkeys.lockHint') }}
+    </p>
+  </div>
 </template>
diff --git a/apps/client/src/features/settings/sections/LanguageSection.vue b/apps/client/src/features/settings/sections/LanguageSection.vue
index 634084d..2a33c0d 100644
--- a/apps/client/src/features/settings/sections/LanguageSection.vue
+++ b/apps/client/src/features/settings/sections/LanguageSection.vue
@@ -11,15 +11,13 @@ const langOptions = computed(() => [
 </script>
 
 <template>
-  <Fieldset :legend="t('language')">
-    <SelectButton
-      v-model="apiLang"
-      :options="langOptions"
-      option-label="label"
-      option-value="value"
-      :allow-empty="false"
-      :aria-label="t('language')"
-      class="w-full"
-    />
-  </Fieldset>
+  <SelectButton
+    v-model="apiLang"
+    :options="langOptions"
+    option-label="label"
+    option-value="value"
+    :allow-empty="false"
+    :aria-label="t('language')"
+    fluid
+  />
 </template>
diff --git a/apps/client/src/features/settings/sections/MapSection.vue b/apps/client/src/features/settings/sections/MapSection.vue
index 957d51f..77d71d8 100644
--- a/apps/client/src/features/settings/sections/MapSection.vue
+++ b/apps/client/src/features/settings/sections/MapSection.vue
@@ -10,24 +10,40 @@ const { localizedMapName } = useMapI18n();
 const mapOptions = computed(() =>
   VISIBLE_MAP_CODES.map((code) => ({ value: code, label: localizedMapName(code) })),
 );
+const currentMapName = computed(() => localizedMapName(mapCode.value));
+
+// Auto-switch is the common case (the game's log drives the map), so the 11-map
+// list stays collapsed behind a disclosure when it's on. With auto-switch off
+// the list is always shown — manual selection is the only way to change maps.
+const manualOpen = ref(false);
 </script>
 
 <template>
-  <Fieldset :legend="t('map')">
-    <div class="space-y-3">
-      <Select
-        v-model="mapCode"
-        :options="mapOptions"
-        option-label="label"
-        option-value="value"
-        :aria-label="t('map')"
-        fluid
-      />
-      <div class="flex items-center justify-between gap-3">
-        <label class="text-sm" for="map-auto-switch">{{ t('autoMapSwitch') }}</label>
-        <ToggleSwitch v-model="autoMapSwitch" input-id="map-auto-switch" />
-      </div>
-      <p class="text-[10px] leading-relaxed opacity-70">{{ t('autoMapSwitchHint') }}</p>
+  <div class="space-y-3">
+    <div class="flex items-center justify-between gap-3">
+      <label class="text-sm" for="map-auto-switch">{{ t('autoMapSwitch') }}</label>
+      <ToggleSwitch v-model="autoMapSwitch" input-id="map-auto-switch" />
     </div>
-  </Fieldset>
+
+    <button
+      v-if="autoMapSwitch"
+      type="button"
+      class="border-surface-700 hover:bg-surface-800 flex w-full items-center justify-between gap-2 rounded-md border px-3 py-2 text-left text-sm transition-colors"
+      @click="manualOpen = !manualOpen"
+    >
+      <span class="truncate">{{ currentMapName }}</span>
+      <i class="pi text-xs opacity-60" :class="manualOpen ? 'pi-chevron-up' : 'pi-chevron-down'" />
+    </button>
+
+    <Listbox
+      v-if="!autoMapSwitch || manualOpen"
+      v-model="mapCode"
+      :options="mapOptions"
+      option-label="label"
+      option-value="value"
+      :aria-label="t('map')"
+      list-style="max-height:8rem"
+      fluid
+    />
+  </div>
 </template>
diff --git a/apps/client/src/features/settings/sections/OverlaySection.vue b/apps/client/src/features/settings/sections/OverlaySection.vue
index d3ca210..14c8b11 100644
--- a/apps/client/src/features/settings/sections/OverlaySection.vue
+++ b/apps/client/src/features/settings/sections/OverlaySection.vue
@@ -2,7 +2,11 @@
 import { useOverlayStore } from '@/features/overlay/store';
 import { useOverlaySync } from '@/features/overlay/composables/useOverlaySync';
 
-const { alwaysOnTop: overlayAlwaysOnTop, zoom: overlayZoom } = storeToRefs(useOverlayStore());
+const {
+  alwaysOnTop: overlayAlwaysOnTop,
+  zoom: overlayZoom,
+  minimizeToTray: overlayMinimizeToTray,
+} = storeToRefs(useOverlayStore());
 const { opacityPercent, mapOpacityPercent, mapOpacityDisabled } = useOverlaySync();
 const { t } = useI18n();
 
@@ -15,61 +19,69 @@ const overlayZoomOptions = computed(() => [
 </script>
 
 <template>
-  <Fieldset :legend="t('overlay.heading')">
-    <div class="space-y-3">
+  <div class="space-y-3">
+    <div class="flex items-center justify-between gap-3">
+      <label class="text-sm" for="overlay-always-on-top">{{ t('overlay.alwaysOnTop') }}</label>
+      <ToggleSwitch v-model="overlayAlwaysOnTop" input-id="overlay-always-on-top" />
+    </div>
+
+    <div>
       <div class="flex items-center justify-between gap-3">
-        <label class="text-sm" for="overlay-always-on-top">{{ t('overlay.alwaysOnTop') }}</label>
-        <ToggleSwitch v-model="overlayAlwaysOnTop" input-id="overlay-always-on-top" />
+        <label class="text-sm" for="overlay-minimize-tray">{{ t('overlay.minimizeToTray') }}</label>
+        <ToggleSwitch v-model="overlayMinimizeToTray" input-id="overlay-minimize-tray" />
       </div>
+      <p class="mt-1.5 text-[10px] leading-relaxed opacity-70">
+        {{ t('overlay.minimizeToTrayHint') }}
+      </p>
+    </div>
 
-      <div>
-        <div class="mb-1.5 flex items-center justify-between gap-3">
-          <label class="text-xs opacity-70" for="overlay-opacity">{{ t('overlay.opacity') }}</label>
-          <span class="text-xs tabular-nums opacity-70">{{ opacityPercent }}%</span>
-        </div>
-        <Slider
-          v-model="opacityPercent"
-          :min="30"
-          :max="100"
-          :step="5"
-          input-id="overlay-opacity"
-          class="w-full"
-        />
+    <div>
+      <div class="mb-1.5 flex items-center justify-between gap-3">
+        <label class="text-xs opacity-70" for="overlay-opacity">{{ t('overlay.opacity') }}</label>
+        <span class="text-xs tabular-nums opacity-70">{{ opacityPercent }}%</span>
       </div>
+      <Slider
+        v-model="opacityPercent"
+        :min="30"
+        :max="100"
+        :step="5"
+        input-id="overlay-opacity"
+        class="w-full"
+      />
+    </div>
 
-      <div :class="mapOpacityDisabled ? 'opacity-50' : ''">
-        <div class="mb-1.5 flex items-center justify-between gap-3">
-          <label class="text-xs opacity-70" for="overlay-map-opacity">
-            {{ t('overlay.mapOpacity') }}
-          </label>
-          <span class="text-xs tabular-nums opacity-70">{{ mapOpacityPercent }}%</span>
-        </div>
-        <Slider
-          v-model="mapOpacityPercent"
-          :min="0"
-          :max="100"
-          :step="5"
-          :disabled="mapOpacityDisabled"
-          input-id="overlay-map-opacity"
-          class="w-full"
-        />
-        <p v-if="mapOpacityDisabled" class="mt-1.5 text-[10px] leading-relaxed opacity-70">
-          {{ t('overlay.mapOpacityHint') }}
-        </p>
+    <div :class="mapOpacityDisabled ? 'opacity-50' : ''">
+      <div class="mb-1.5 flex items-center justify-between gap-3">
+        <label class="text-xs opacity-70" for="overlay-map-opacity">
+          {{ t('overlay.mapOpacity') }}
+        </label>
+        <span class="text-xs tabular-nums opacity-70">{{ mapOpacityPercent }}%</span>
       </div>
+      <Slider
+        v-model="mapOpacityPercent"
+        :min="0"
+        :max="100"
+        :step="5"
+        :disabled="mapOpacityDisabled"
+        input-id="overlay-map-opacity"
+        class="w-full"
+      />
+      <p v-if="mapOpacityDisabled" class="mt-1.5 text-[10px] leading-relaxed opacity-70">
+        {{ t('overlay.mapOpacityHint') }}
+      </p>
+    </div>
 
-      <div>
-        <p class="mb-1.5 text-xs opacity-60">{{ t('overlay.zoom') }}</p>
-        <SelectButton
-          v-model="overlayZoom"
-          :options="overlayZoomOptions"
-          option-label="label"
-          option-value="value"
-          :allow-empty="false"
-          size="small"
-          class="w-full"
-        />
-      </div>
+    <div>
+      <p class="mb-1.5 text-xs opacity-60">{{ t('overlay.zoom') }}</p>
+      <SelectButton
+        v-model="overlayZoom"
+        :options="overlayZoomOptions"
+        option-label="label"
+        option-value="value"
+        :allow-empty="false"
+        size="small"
+        fluid
+      />
     </div>
-  </Fieldset>
+  </div>
 </template>
diff --git a/apps/client/src/features/settings/sections/PairingSection.vue b/apps/client/src/features/settings/sections/PairingSection.vue
index 753d4ee..b9b1b88 100644
--- a/apps/client/src/features/settings/sections/PairingSection.vue
+++ b/apps/client/src/features/settings/sections/PairingSection.vue
@@ -15,7 +15,7 @@ const { t } = useI18n();
 </script>
 
 <template>
-  <Fieldset :legend="t('pairing.heading')">
+  <div>
     <p class="text-xs opacity-70 mb-3 leading-snug">{{ t('pairing.sectionHint') }}</p>
     <Button
       :label="t('pairing.open')"
@@ -24,5 +24,5 @@ const { t } = useI18n();
       class="w-full"
       @click="pairingModalOpen = true"
     />
-  </Fieldset>
+  </div>
 </template>
diff --git a/apps/client/src/features/settings/sections/PathsSection.vue b/apps/client/src/features/settings/sections/PathsSection.vue
index 594efa8..b0c4dbc 100644
--- a/apps/client/src/features/settings/sections/PathsSection.vue
+++ b/apps/client/src/features/settings/sections/PathsSection.vue
@@ -21,11 +21,13 @@ const {
   canSavePaths,
   savePaths,
   statusIconClass,
+  deleteScreenshots,
+  setDeleteScreenshots,
 } = useServerPaths(canEditPaths);
 </script>
 
 <template>
-  <Fieldset :legend="t('paths.heading')">
+  <div class="space-y-3">
     <Message
       v-if="pathsError"
       :severity="pathsError.kind === 'no-helper' ? 'warn' : 'error'"
@@ -64,6 +66,7 @@ const {
             :readonly="!canEditPaths"
             size="small"
             fluid
+            @keyup.enter="canSavePaths && savePaths()"
           />
         </IconField>
       </div>
@@ -82,6 +85,7 @@ const {
             :readonly="!canEditPaths"
             size="small"
             fluid
+            @keyup.enter="canSavePaths && savePaths()"
           />
         </IconField>
       </div>
@@ -102,6 +106,25 @@ const {
       <p v-else class="text-[10px] leading-relaxed opacity-70">
         {{ t('paths.mobileHint') }}
       </p>
+
+      <div class="border-t border-surface-700 pt-3">
+        <div class="flex items-center justify-between gap-3">
+          <label for="delete-screenshots-toggle" class="text-xs">
+            {{ t('paths.deleteScreenshots') }}
+          </label>
+          <!-- Editable everywhere incl. phones (unlike the paths): a switch
+               needs no keyboard and a stray flip is a recoverable, single PUT. -->
+          <ToggleSwitch
+            class="shrink-0"
+            input-id="delete-screenshots-toggle"
+            :model-value="deleteScreenshots"
+            @update:model-value="setDeleteScreenshots"
+          />
+        </div>
+        <p class="mt-1.5 text-[10px] leading-relaxed opacity-70">
+          {{ t('paths.deleteScreenshotsHint') }}
+        </p>
+      </div>
     </div>
-  </Fieldset>
+  </div>
 </template>
diff --git a/apps/client/src/features/settings/sections/PlayerSection.vue b/apps/client/src/features/settings/sections/PlayerSection.vue
index 8663221..80fc02c 100644
--- a/apps/client/src/features/settings/sections/PlayerSection.vue
+++ b/apps/client/src/features/settings/sections/PlayerSection.vue
@@ -3,27 +3,18 @@ import { useMapSettingsStore } from '@/features/map/store';
 
 const { playerFollow } = storeToRefs(useMapSettingsStore());
 const { t } = useI18n();
-
-const playerFollowOptions = computed(() => [
-  { label: t('playerFollowOptions.off'), value: 'off' as const },
-  { label: t('playerFollowOptions.sm'), value: 'sm' as const },
-  { label: t('playerFollowOptions.md'), value: 'md' as const },
-  { label: t('playerFollowOptions.lg'), value: 'lg' as const },
-]);
 </script>
 
 <template>
-  <Fieldset :legend="t('player')">
-    <p class="mb-1.5 text-xs opacity-60">{{ t('playerFollow') }}</p>
-    <SelectButton
-      v-model="playerFollow"
-      :options="playerFollowOptions"
-      option-label="label"
-      option-value="value"
-      :allow-empty="false"
-      size="small"
-      class="w-full"
-    />
+  <div>
+    <div class="flex items-center justify-between gap-3">
+      <label class="text-sm" for="player-follow">{{ t('playerFollow') }}</label>
+      <ToggleSwitch
+        :model-value="playerFollow === 'on'"
+        input-id="player-follow"
+        @update:model-value="(v: boolean) => (playerFollow = v ? 'on' : 'off')"
+      />
+    </div>
     <p class="mt-1.5 text-[10px] leading-relaxed opacity-70">{{ t('playerFollowHint') }}</p>
-  </Fieldset>
+  </div>
 </template>
diff --git a/apps/client/src/features/tarkov-time/TarkovTimeChip.vue b/apps/client/src/features/tarkov-time/TarkovTimeChip.vue
new file mode 100644
index 0000000..8ad7002
--- /dev/null
+++ b/apps/client/src/features/tarkov-time/TarkovTimeChip.vue
@@ -0,0 +1,92 @@
+<script setup lang="ts">
+import { tarkovTime } from '@shared/tarkov-time';
+import { useOverlayHeaderActive } from '@/features/overlay/composables/useOverlayHeaderActive';
+import type { TransportStatus } from '@/features/server/composables/useServerTransport';
+
+// Always-visible info chip (top-left), shown in every state (idle + locked).
+// In the browser it also folds in the connection-status dot and (on wider
+// screens) the map name, so the right-hand cluster can shrink to just the
+// settings gear on a narrow 320px phone. In the Tauri overlay `status` is
+// omitted (the overlay header renders its own dot) and the map name shows
+// unconditionally.
+const props = defineProps<{
+  mapDisplayName?: string;
+  status?: TransportStatus;
+  /** Browser: hide the map name below ~380px so the chip fits a 320px phone. */
+  compactMapName?: boolean;
+}>();
+
+// Non-interactive. In-game time runs 7× real time, so a fixed interval makes the
+// seconds stutter (a sample lands inside the same second twice). Sample each
+// animation frame and swap the ref only when the shown value changes — each
+// second renders once for its true ~143ms, ticking smoothly without re-rendering
+// 60×/s. (rAF pauses while the tab is hidden, then self-corrects on return.)
+const clock = ref(tarkovTime(Date.now()));
+let raf: number | undefined;
+function tick(): void {
+  const next = tarkovTime(Date.now());
+  if (
+    next.left !== clock.value.left ||
+    next.right !== clock.value.right ||
+    next.seconds !== clock.value.seconds
+  ) {
+    clock.value = next;
+  }
+  raf = requestAnimationFrame(tick);
+}
+onMounted(() => {
+  raf = requestAnimationFrame(tick);
+});
+onBeforeUnmount(() => {
+  if (raf !== undefined) cancelAnimationFrame(raf);
+});
+
+// Slide down out of the way when the overlay drag bar expands; back up after.
+const { active: headerActive } = useOverlayHeaderActive();
+
+const statusDotClass = computed(() => {
+  switch (props.status) {
+    case 'open':
+      return 'pi-circle-fill text-green-500';
+    case 'connecting':
+      return 'pi-circle-fill text-amber-400 animate-pulse';
+    case 'closed':
+      return 'pi-times-circle text-red-500';
+    default:
+      return 'pi-circle text-surface-500';
+  }
+});
+</script>
+
+<template>
+  <!-- Slide via transform (composited), matching the header's reveal. -->
+  <div
+    class="sa-top sa-left pointer-events-none absolute z-[1000] flex h-10 items-center transition-transform duration-200 ease-out"
+    :class="headerActive ? 'translate-y-11' : 'translate-y-0'"
+  >
+    <span
+      class="inline-flex max-w-[16rem] items-center gap-1.5 rounded-md bg-surface-800/70 px-2 py-1 font-mono text-xs tabular-nums text-surface-0 backdrop-blur select-none"
+      aria-hidden="true"
+    >
+      <i v-if="status" :class="['pi text-[9px]', statusDotClass]" />
+      <span
+        >{{ clock.left }}<span class="opacity-50">:{{ clock.seconds }}</span></span
+      >
+      <span class="opacity-40">/</span>
+      <span
+        >{{ clock.right }}<span class="opacity-50">:{{ clock.seconds }}</span></span
+      >
+      <span
+        v-if="mapDisplayName"
+        class="items-center gap-1.5"
+        :class="compactMapName ? 'hidden min-[380px]:inline-flex' : 'inline-flex'"
+      >
+        <span class="opacity-25">|</span>
+        <span class="max-w-[8.75rem] truncate font-sans text-[11px] font-medium opacity-90">{{
+          mapDisplayName
+        }}</span>
+      </span>
+    </span>
+    <span v-if="status" class="sr-only" aria-live="polite">Connection: {{ status }}</span>
+  </div>
+</template>
diff --git a/apps/client/src/features/updater/components/UpdateBanner.vue b/apps/client/src/features/updater/components/UpdateBanner.vue
new file mode 100644
index 0000000..f35b2b4
--- /dev/null
+++ b/apps/client/src/features/updater/components/UpdateBanner.vue
@@ -0,0 +1,71 @@
+<script setup lang="ts">
+import { isTauri } from '@/shared/tauri';
+import { useOverlayStore } from '@/features/overlay/store';
+
+/** Mirrors `UpdateInfo` in src-tauri/src/updater.rs (downloadUrl stays Rust-side). */
+interface UpdateInfo {
+  current: string;
+  latest: string;
+  releaseUrl: string;
+}
+
+const { t } = useI18n();
+const { clickThrough } = storeToRefs(useOverlayStore());
+
+const info = ref<UpdateInfo | null>(null);
+const installing = ref(false);
+const failed = ref(false);
+const dismissed = ref(false);
+
+onMounted(async () => {
+  if (!isTauri) return;
+  try {
+    const { invoke } = await import('@tauri-apps/api/core');
+    info.value = await invoke<UpdateInfo | null>('check_update');
+  } catch (e) {
+    // Convenience check only — offline / rate-limited GitHub is not an error
+    // worth surfacing, the app works fine on the current version.
+    console.warn('[updater] check failed:', e);
+  }
+});
+
+async function install(): Promise<void> {
+  if (installing.value) return;
+  installing.value = true;
+  failed.value = false;
+  try {
+    const { invoke } = await import('@tauri-apps/api/core');
+    // On success the backend swaps the exe, respawns it and exits this
+    // process — there is no resolved state to handle.
+    await invoke('install_update');
+  } catch (e) {
+    console.warn('[updater] install failed:', e);
+    failed.value = true;
+    installing.value = false;
+  }
+}
+</script>
+
+<template>
+  <!-- Hidden while click-through-locked: the banner is interactive chrome. -->
+  <div
+    v-if="info && !dismissed && !clickThrough"
+    class="border-surface-700 bg-surface-900/95 fixed bottom-2 left-1/2 z-[1100] flex -translate-x-1/2 items-center gap-2 rounded-lg border px-3 py-1.5 text-xs shadow-lg"
+  >
+    <template v-if="!failed">
+      <span>{{ t('updater.available', { version: info.latest }) }}</span>
+      <Button
+        size="small"
+        :label="installing ? t('updater.installing') : t('updater.install')"
+        :loading="installing"
+        @click="install"
+      />
+    </template>
+    <span v-else class="text-amber-400">{{ t('updater.error') }}</span>
+    <button
+      class="pi pi-times text-surface-400 hover:text-surface-0 cursor-pointer text-[10px]"
+      :aria-label="t('close')"
+      @click="dismissed = true"
+    />
+  </div>
+</template>
diff --git a/apps/client/src/main.ts b/apps/client/src/main.ts
index 8c429c3..9df77da 100644
--- a/apps/client/src/main.ts
+++ b/apps/client/src/main.ts
@@ -1,5 +1,6 @@
 import PrimeVue from 'primevue/config';
 import ConfirmationService from 'primevue/confirmationservice';
+import Tooltip from 'primevue/tooltip';
 import App from './App.vue';
 import { router } from '@/app/router';
 import { i18n } from '@/features/i18n';
@@ -57,4 +58,5 @@ app.use(PrimeVue, {
     },
   },
 });
+app.directive('tooltip', Tooltip);
 app.mount('#app');
diff --git a/apps/client/src/pages/index.vue b/apps/client/src/pages/index.vue
index b9f510e..a23abac 100644
--- a/apps/client/src/pages/index.vue
+++ b/apps/client/src/pages/index.vue
@@ -1,28 +1,30 @@
 <script setup lang="ts">
 import MapView from '@/features/map/components/MapView.vue';
 import OverlayHeader from '@/features/overlay/components/OverlayHeader.vue';
+import OverlayBorder from '@/features/overlay/components/OverlayBorder.vue';
+import TarkovTimeChip from '@/features/tarkov-time/TarkovTimeChip.vue';
 import OverlayLockIndicator from '@/features/overlay/components/OverlayLockIndicator.vue';
 import OverlayErrors from '@/features/overlay/components/OverlayErrors.vue';
 import AirdropStatusBanner from '@/features/airdrop/components/AirdropStatusBanner.vue';
 import { useMapSettingsStore } from '@/features/map/store';
-import { useOverlayStore } from '@/features/overlay/store';
+import { useOverlayLock } from '@/features/overlay/composables/useOverlayLock';
 import { useHotkeysStore } from '@/features/hotkeys/store';
-import { useTauriOverlay } from '@/features/overlay/composables/useTauriOverlay';
+import { showOverlayChrome } from '@/shared/tauri';
 import { useTransportStatus } from '@/features/server/composables/useTransportStatus';
-import { useGlobalShortcut } from '@/features/hotkeys/composables/useGlobalShortcut';
+import { useServerEvent } from '@/features/server/composables/useServerEvents';
 import { useCloseConfirm } from '@/features/overlay/composables/useCloseConfirm';
 import { useAirdropStore } from '@/features/airdrop/store';
 import { useAirdropTracker } from '@/features/airdrop/composables/useAirdropTracker';
 
 const { mapCode } = storeToRefs(useMapSettingsStore());
-const { clickThrough: overlayClickThrough } = storeToRefs(useOverlayStore());
-const { lockHotkey, zoomInHotkey, zoomOutHotkey, floorUpHotkey, floorDownHotkey, airdropHotkey } =
-  storeToRefs(useHotkeysStore());
+const { showControls } = useOverlayLock();
+// Only the lock combo is still client-owned; the rest arrive as backend
+// `command` events (see below) so they fire regardless of focus.
+const { lockHotkey } = storeToRefs(useHotkeysStore());
 
 const airdropStore = useAirdropStore();
 useAirdropTracker();
 
-const { isTauri } = useTauriOverlay();
 const status = useTransportStatus();
 const confirmClose = useCloseConfirm();
 
@@ -33,11 +35,30 @@ const mapError = ref<string | null>(null);
 // defineExpose. `?.` keeps every shortcut handler safe to call before the
 // component mounts (e.g. immediately after a `:key` swap on map change).
 const mapRef = ref<InstanceType<typeof MapView> | null>(null);
-useGlobalShortcut(isTauri, zoomInHotkey, () => mapRef.value?.zoomIn());
-useGlobalShortcut(isTauri, zoomOutHotkey, () => mapRef.value?.zoomOut());
-useGlobalShortcut(isTauri, floorUpHotkey, () => mapRef.value?.nextFloor());
-useGlobalShortcut(isTauri, floorDownHotkey, () => mapRef.value?.prevFloor());
-useGlobalShortcut(isTauri, airdropHotkey, () => airdropStore.press());
+
+// Hotkeys are owned by the backend now: it registers OS-global shortcuts (which
+// fire even while the game is focused) and broadcasts a `command` event. Every
+// client — overlay webview, browser, LAN phone — dispatches it here, so the
+// action runs regardless of which client (if any) has focus.
+useServerEvent('command', (msg) => {
+  switch (msg.action) {
+    case 'zoom-in':
+      mapRef.value?.zoomIn();
+      break;
+    case 'zoom-out':
+      mapRef.value?.zoomOut();
+      break;
+    case 'floor-up':
+      mapRef.value?.floorUp();
+      break;
+    case 'floor-down':
+      mapRef.value?.floorDown();
+      break;
+    case 'airdrop':
+      airdropStore.press();
+      break;
+  }
+});
 </script>
 
 <template>
@@ -49,22 +70,19 @@ useGlobalShortcut(isTauri, airdropHotkey, () => airdropStore.press());
     @map-error="mapError = $event"
   />
 
-  <OverlayHeader
-    :map-display-name="mapDisplayName"
-    :status="status"
-    :is-tauri="isTauri"
-    :overlay-click-through="overlayClickThrough"
-    @close="confirmClose"
-  />
+  <OverlayHeader :status="status" :tauri-chrome="showOverlayChrome" @close="confirmClose" />
 
   <OverlayErrors :map-error="mapError" @dismiss-map="mapError = null" @retry="mapRef?.reload()" />
 
   <AirdropStatusBanner />
 
-  <OverlayLockIndicator
-    v-if="isTauri"
-    :lock-hotkey="lockHotkey"
-    :overlay-click-through="overlayClickThrough"
-    @lock="overlayClickThrough = true"
+  <TarkovTimeChip
+    :map-display-name="mapDisplayName"
+    :status="showOverlayChrome ? undefined : status"
+    :compact-map-name="!showOverlayChrome"
   />
+
+  <OverlayBorder v-if="showOverlayChrome && showControls" />
+
+  <OverlayLockIndicator v-if="showOverlayChrome" :lock-hotkey="lockHotkey" />
 </template>
diff --git a/apps/client/src/shared/tauri.ts b/apps/client/src/shared/tauri.ts
index b9aea26..9f21b39 100644
--- a/apps/client/src/shared/tauri.ts
+++ b/apps/client/src/shared/tauri.ts
@@ -8,3 +8,25 @@
  * future SSR experiments).
  */
 export const isTauri = typeof window !== 'undefined' && '__TAURI_INTERNALS__' in window;
+
+/**
+ * DEV-only flag to render the Tauri overlay chrome (drag bar, animated border,
+ * lock indicator) in a plain browser, so the overlay UX can be previewed and
+ * iterated without a Tauri build. It ONLY flips render gates — native window
+ * calls and the IPC transport still key off `isTauri`, so they stay no-ops off
+ * real Tauri. Enable via `?overlay` in the URL or
+ * localStorage['tc.dev.overlayChrome'] = '1'.
+ */
+function previewOverlayChrome(): boolean {
+  if (!import.meta.env.DEV || typeof window === 'undefined') return false;
+  try {
+    return (
+      new URLSearchParams(window.location.search).has('overlay') ||
+      window.localStorage.getItem('tc.dev.overlayChrome') === '1'
+    );
+  } catch {
+    return false;
+  }
+}
+
+export const showOverlayChrome = isTauri || previewOverlayChrome();
diff --git a/apps/client/src/styles.css b/apps/client/src/styles.css
index 80598f9..51ce8eb 100644
--- a/apps/client/src/styles.css
+++ b/apps/client/src/styles.css
@@ -80,6 +80,12 @@ body,
   height: 100%;
   margin: 0;
   background: transparent;
+  /* Fixed full-screen app shell — never page-scroll. On iOS Safari a scrollable
+     body lets the bottom toolbar retract, which swells `dvh` and breaks the
+     vertically-centred rail/flyout. Locking scroll keeps the toolbar (and the
+     `100%`/`svh` height) stable; `100%` resolves to the small viewport. */
+  overflow: hidden;
+  overscroll-behavior: none;
 }
 
 /* Tauri overlay mode: round the painted area for a softer overlay shape.
@@ -103,20 +109,48 @@ html.overlay-window #app {
   opacity: var(--overlay-opacity, 1);
 }
 
-/* Unlocked overlay: trace the rounded window edge so the user can find the
-   resize/drag boundary even after they've dialled the map opacity to 0 and
-   the corners are otherwise invisible. ::after sits inside body's clip, so
-   the border lines up with the rounded-rectangle boundary itself. Locked
-   state hides it — the lock indicator already conveys "no interaction". */
-html.overlay-window.overlay-unlocked body::after {
-  content: '';
+/* Unlocked overlay: an animated dashed boundary traces the rounded window edge
+   so the player can find the drag/resize boundary even at 0 map opacity. It's
+   an SVG stroke (OverlayBorder.vue), not a CSS border, so the marching dashes
+   follow the rounded corners; teleported to <body> so the opacity slider (which
+   dims #app) leaves it at full strength. Mounted only while unlocked. */
+.overlay-border {
   position: fixed;
   inset: 0;
-  border: 2px solid rgb(from var(--p-primary-400) r g b / 0.9);
-  border-radius: 12px;
+  width: 100%;
+  height: 100%;
   pointer-events: none;
   z-index: 9999;
 }
+.overlay-border rect {
+  x: 1.5px;
+  y: 1.5px;
+  width: calc(100% - 3px);
+  height: calc(100% - 3px);
+  rx: 11px;
+  ry: 11px;
+  fill: none;
+  /* Fallback for older engines without relative-color syntax (cf. .leaflet-container). */
+  stroke: var(--p-primary-400);
+  stroke: rgb(from var(--p-primary-400) r g b / 0.9);
+  stroke-width: 2px;
+  /* The rect carries pathLength="100", so dash + offset are in normalized units
+     where the whole perimeter = 100. A 0.5+0.5 period divides 100 exactly (100
+     dashes) → the loop closes seamlessly at the start corner regardless of the
+     (resizable) window size, and one period of offset animates seamlessly. */
+  stroke-dasharray: 0.5 0.5;
+  animation: overlay-ants 0.8s linear infinite;
+}
+@keyframes overlay-ants {
+  to {
+    stroke-dashoffset: -1;
+  }
+}
+@media (prefers-reduced-motion: reduce) {
+  .overlay-border rect {
+    animation: none;
+  }
+}
 
 .leaflet-container {
   /* Fallback for older engines that don't grok relative-color syntax. */
@@ -146,6 +180,46 @@ html.overlay-window.overlay-unlocked body::after {
   inset: 0;
 }
 
+/* Off-screen extract arrows (#18). Plain overlay over the Leaflet container
+ * (not a pane), so the arrows stay pixel-fixed to the viewport edge while the
+ * map pane is dragged. Above the map, below Leaflet controls; never clickable. */
+.edge-indicators {
+  position: absolute;
+  inset: 0;
+  z-index: 600;
+  overflow: hidden;
+  pointer-events: none;
+}
+.edge-indicator {
+  position: absolute;
+  width: 22px;
+  height: 22px;
+  margin-left: -11px;
+  margin-top: -11px;
+  transform-origin: center;
+  filter: drop-shadow(0 0 3px rgb(0 0 0 / 0.85));
+}
+
+/* Safe-area offsets for floating controls (#24) — clear the notch / Dynamic
+ * Island / home indicator / rounded corners on phones (index.html sets
+ * viewport-fit=cover so the page draws under them). The insets are 0 on
+ * desktop, so these collapse to the base 0.75rem / 0.5rem there. */
+.sa-top {
+  top: calc(0.75rem + env(safe-area-inset-top));
+}
+.sa-bottom {
+  bottom: calc(0.75rem + env(safe-area-inset-bottom));
+}
+.sa-left {
+  left: calc(0.75rem + env(safe-area-inset-left));
+}
+.sa-right {
+  right: calc(0.75rem + env(safe-area-inset-right));
+}
+.sa-pt {
+  padding-top: calc(0.5rem + env(safe-area-inset-top));
+}
+
 /* Tooltip container — Leaflet adds .leaflet-tooltip; we hide its built-in
  * pseudo-element callout and let the per-row stripes carry faction colour
  * (rows live inside, one per distinct name). Padding goes on the rows so
diff --git a/apps/desktop/README.md b/apps/desktop/README.md
index 2aa2bdd..e5967b1 100644
--- a/apps/desktop/README.md
+++ b/apps/desktop/README.md
@@ -13,15 +13,14 @@ serves the same files for phone access on `:47474`).
 ## Dev
 
 ```pwsh
-# Terminal 1 — start the Vite dev server (from repo root)
-pnpm dev
-
-# Terminal 2 — launch the Tauri window
+# One command — Tauri spawns Vite, then opens the window
 pnpm --filter @tarkov-checker/desktop tauri:dev
 ```
 
-`beforeDevCommand` is intentionally empty in `tauri.conf.json` so the
-Vite server stays under Turbo's orchestration and isn't double-spawned.
+`beforeDevCommand` in `tauri.conf.json` is
+`pnpm --filter @tarkov-checker/client dev`, so Tauri starts the Vite
+dev server (`:5173`) itself and shuts it down on exit — no separate
+terminal needed.
 
 ## Production build
 
@@ -32,7 +31,31 @@ pnpm --filter @tarkov-checker/desktop tauri:build
 `beforeBuildCommand` builds the client first; Tauri then bundles
 `apps/client/dist` into the installer.
 
-## Out of scope (this bootstrap)
-
-Transparency, always-on-top, click-through, tray icon, custom commands.
-These land in a later session.
+## What this crate does
+
+More than a thin wrapper now. The same `.exe` is both the overlay and a
+local backend:
+
+- **Frameless transparent overlay** — `decorations: false`,
+  `transparent: true`, `shadow: false`. Always-on-top, click-through
+  (lock), opacity and zoom are driven from the webview via Tauri window
+  APIs.
+- **In-process axum HTTP server on `0.0.0.0:47474`** — `GET /api/ping`,
+  `GET`/`PUT /api/config`, `GET`/`PUT /api/hotkeys`,
+  `POST /api/hotkeys/{suspend,resume}`, and `GET /events` (SSE). Backs
+  any same-Wi-Fi browser/phone; release builds also serve the embedded
+  SPA from `/`.
+- **Backend-owned OS-global hotkeys** — zoom/floor/airdrop combos are
+  registered by the backend and broadcast as `command` events to every
+  client (overlay, browser, LAN phone). Only the overlay lock combo is
+  client-registered.
+- **Tauri IPC commands** — `get_config`, `update_config`, `get_hotkeys`,
+  `update_hotkeys`, `suspend_hotkeys`, `resume_hotkeys`, `pairing_qr`
+  (LAN QR pairing).
+- **System-tray icon** — created client-side via the Tauri JS tray API
+  (`apps/client/.../overlay/composables/useTrayIcon.ts`): toggle-lock,
+  show window, quit. A richer Rust-side tray menu (pair phone / copy LAN
+  URL) is still planned — see `PLAN-LAN-AND-TRAY.md`, section E.
+
+For full detail see the repo `CLAUDE.md` — "Desktop overlay",
+"Backend-owned hotkeys", and "In-process HTTP server".
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index 45465de..92b9ab4 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -7,6 +7,7 @@
     "tauri": "tauri",
     "tauri:dev": "tauri dev",
     "tauri:build": "tauri build",
+    "backend:dev": "cargo run --manifest-path src-tauri/Cargo.toml --bin tarkov-checker-headless",
     "lint": "echo \"(no JS sources to lint)\"",
     "typecheck": "echo \"(no TS sources to typecheck)\""
   },
diff --git a/apps/desktop/src-tauri/Cargo.lock b/apps/desktop/src-tauri/Cargo.lock
index ac34106..c910f29 100644
--- a/apps/desktop/src-tauri/Cargo.lock
+++ b/apps/desktop/src-tauri/Cargo.lock
@@ -47,6 +47,27 @@ version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
+[[package]]
+name = "arboard"
+version = "3.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf"
+dependencies = [
+ "clipboard-win",
+ "image",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "parking_lot",
+ "percent-encoding",
+ "windows-sys 0.60.2",
+ "wl-clipboard-rs",
+ "x11rb",
+]
+
 [[package]]
 name = "async-trait"
 version = "0.1.89"
@@ -256,6 +277,12 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
 [[package]]
 name = "bytes"
 version = "1.11.1"
@@ -387,6 +414,15 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
+[[package]]
+name = "clipboard-win"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4"
+dependencies = [
+ "error-code",
+]
+
 [[package]]
 name = "combine"
 version = "4.6.7"
@@ -432,7 +468,7 @@ dependencies = [
  "bitflags 2.11.1",
  "core-foundation",
  "core-graphics-types",
- "foreign-types",
+ "foreign-types 0.5.0",
  "libc",
 ]
 
@@ -480,6 +516,12 @@ version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
 [[package]]
 name = "crypto-common"
 version = "0.1.7"
@@ -763,6 +805,12 @@ dependencies = [
  "tendril",
 ]
 
+[[package]]
+name = "downcast-rs"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
+
 [[package]]
 name = "dpi"
 version = "0.1.2"
@@ -867,12 +915,24 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "error-code"
+version = "3.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dea2df4cf52843e0452895c455a1a2cfbb842a1e7329671acf418fdc53ed4c59"
+
 [[package]]
 name = "fastrand"
 version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
 
+[[package]]
+name = "fax"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caf1079563223d5d59d83c85886a56e586cfd5c1a26292e971a0fa266531ac5a"
+
 [[package]]
 name = "fdeflate"
 version = "0.3.7"
@@ -917,6 +977,12 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
+[[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
 [[package]]
 name = "flate2"
 version = "1.1.9"
@@ -945,6 +1011,15 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
 
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared 0.1.1",
+]
+
 [[package]]
 name = "foreign-types"
 version = "0.5.0"
@@ -952,7 +1027,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"
 dependencies = [
  "foreign-types-macros",
- "foreign-types-shared",
+ "foreign-types-shared 0.3.1",
 ]
 
 [[package]]
@@ -966,6 +1041,12 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
 [[package]]
 name = "foreign-types-shared"
 version = "0.3.1"
@@ -1394,6 +1475,17 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+ "zerocopy",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -1509,6 +1601,22 @@ dependencies = [
  "want",
 ]
 
+[[package]]
+name = "hyper-tls"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
+dependencies = [
+ "bytes",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "native-tls",
+ "tokio",
+ "tokio-native-tls",
+ "tower-service",
+]
+
 [[package]]
 name = "hyper-util"
 version = "0.1.20"
@@ -1681,6 +1789,20 @@ dependencies = [
  "icu_properties",
 ]
 
+[[package]]
+name = "image"
+version = "0.25.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "moxcms",
+ "num-traits",
+ "png 0.18.1",
+ "tiff",
+]
+
 [[package]]
 name = "indexmap"
 version = "1.9.3"
@@ -2060,6 +2182,16 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "moxcms"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"
+dependencies = [
+ "num-traits",
+ "pxfm",
+]
+
 [[package]]
 name = "muda"
 version = "0.19.2"
@@ -2081,6 +2213,23 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "native-tls"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "465500e14ea162429d264d44189adc38b199b62b1c21eea9f69e4b73cb03bbf2"
+dependencies = [
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework",
+ "security-framework-sys",
+ "tempfile",
+]
+
 [[package]]
 name = "ndk"
 version = "0.9.0"
@@ -2140,6 +2289,15 @@ version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
 
+[[package]]
+name = "nom"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "notify"
 version = "6.1.1"
@@ -2230,6 +2388,7 @@ dependencies = [
  "block2",
  "objc2",
  "objc2-core-foundation",
+ "objc2-core-graphics",
  "objc2-foundation",
 ]
 
@@ -2411,12 +2570,65 @@ version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
+[[package]]
+name = "openssl"
+version = "0.10.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a45fa2aa886c42762255da344f0a0d313e254066c46aad76f300c3d3da62d967"
+dependencies = [
+ "bitflags 2.11.1",
+ "cfg-if",
+ "foreign-types 0.3.2",
+ "libc",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.116"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28a22dc7140cda5f096e5e7724a6962ca81a7f8bfd2979f9b18c11af56318c4"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "option-ext"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
+[[package]]
+name = "os_pipe"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "pango"
 version = "0.18.3"
@@ -2471,6 +2683,17 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
+[[package]]
+name = "petgraph"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
+dependencies = [
+ "fixedbitset",
+ "hashbrown 0.15.5",
+ "indexmap 2.14.0",
+]
+
 [[package]]
 name = "phf"
 version = "0.13.1"
@@ -2544,7 +2767,7 @@ checksum = "092791278e026273c1b65bbdcfbba3a300f2994c896bd01ab01da613c29c46f1"
 dependencies = [
  "base64 0.22.1",
  "indexmap 2.14.0",
- "quick-xml",
+ "quick-xml 0.39.4",
  "serde",
  "time",
 ]
@@ -2690,12 +2913,33 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "pxfm"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0c5ccf5294c6ccd63a74f1565028353830a9c2f5eb0c682c355c471726a6e3f"
+
 [[package]]
 name = "qrcode"
 version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d68782463e408eb1e668cf6152704bd856c78c5b6417adaee3203d8f4c1fc9ec"
 
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
+
+[[package]]
+name = "quick-xml"
+version = "0.37.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "quick-xml"
 version = "0.39.4"
@@ -2801,6 +3045,42 @@ version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
 
+[[package]]
+name = "reqwest"
+version = "0.12.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-tls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "native-tls",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustls-pki-types",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "tokio",
+ "tokio-native-tls",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "reqwest"
 version = "0.13.4"
@@ -2897,6 +3177,15 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "rustls-pki-types"
+version = "1.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30a7197ae7eb376e574fe940d068c30fe0462554a3ddbe4eca7838e049c937a9"
+dependencies = [
+ "zeroize",
+]
+
 [[package]]
 name = "rustversion"
 version = "1.0.22"
@@ -2918,6 +3207,15 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "schannel"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "schemars"
 version = "0.8.22"
@@ -2975,6 +3273,29 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
+[[package]]
+name = "security-framework"
+version = "3.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "selectors"
 version = "0.36.1"
@@ -3419,7 +3740,7 @@ dependencies = [
  "tao-macros",
  "unicode-segmentation",
  "url",
- "windows",
+ "windows 0.61.3",
  "windows-core 0.61.2",
  "windows-version",
  "x11-dl",
@@ -3444,11 +3765,12 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "tarkov-checker-desktop"
-version = "0.0.0"
+version = "0.1.0"
 dependencies = [
  "anyhow",
  "axum",
  "futures-util",
+ "global-hotkey",
  "local-ip-address",
  "mime_guess",
  "notify",
@@ -3456,18 +3778,23 @@ dependencies = [
  "once_cell",
  "qrcode",
  "regex",
+ "reqwest 0.12.28",
  "rust-embed",
  "serde",
  "serde_json",
  "tauri",
  "tauri-build",
+ "tauri-plugin-clipboard-manager",
  "tauri-plugin-global-shortcut",
  "tauri-plugin-window-state",
+ "tauri-winrt-notification",
  "thiserror 1.0.69",
  "tokio",
  "tokio-stream",
  "tower",
  "tower-http",
+ "trash",
+ "windows-sys 0.59.0",
  "winreg 0.52.0",
 ]
 
@@ -3501,7 +3828,7 @@ dependencies = [
  "percent-encoding",
  "plist",
  "raw-window-handle",
- "reqwest",
+ "reqwest 0.13.4",
  "serde",
  "serde_json",
  "serde_repr",
@@ -3519,7 +3846,7 @@ dependencies = [
  "webkit2gtk",
  "webview2-com",
  "window-vibrancy",
- "windows",
+ "windows 0.61.3",
 ]
 
 [[package]]
@@ -3600,6 +3927,21 @@ dependencies = [
  "walkdir",
 ]
 
+[[package]]
+name = "tauri-plugin-clipboard-manager"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "206dc20af4ed210748ba945c2774e60fd0acd52b9a73a028402caf809e9b6ecf"
+dependencies = [
+ "arboard",
+ "log",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.18",
+]
+
 [[package]]
 name = "tauri-plugin-global-shortcut"
 version = "2.3.1"
@@ -3652,7 +3994,7 @@ dependencies = [
  "url",
  "webkit2gtk",
  "webview2-com",
- "windows",
+ "windows 0.61.3",
 ]
 
 [[package]]
@@ -3677,7 +4019,7 @@ dependencies = [
  "url",
  "webkit2gtk",
  "webview2-com",
- "windows",
+ "windows 0.61.3",
  "wry",
 ]
 
@@ -3730,6 +4072,31 @@ dependencies = [
  "toml 1.1.2+spec-1.1.0",
 ]
 
+[[package]]
+name = "tauri-winrt-notification"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b1e66e07de489fe43a46678dd0b8df65e0c973909df1b60ba33874e297ba9b9"
+dependencies = [
+ "quick-xml 0.37.5",
+ "thiserror 2.0.18",
+ "windows 0.61.3",
+ "windows-version",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.2",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "tendril"
 version = "0.5.0"
@@ -3780,6 +4147,20 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "tiff"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b63feaf3343d35b6ca4d50483f94843803b0f51634937cc2ec519fc32232bc52"
+dependencies = [
+ "fax",
+ "flate2",
+ "half",
+ "quick-error",
+ "weezl",
+ "zune-jpeg",
+]
+
 [[package]]
 name = "time"
 version = "0.3.47"
@@ -3862,6 +4243,16 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "tokio-native-tls"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
+dependencies = [
+ "native-tls",
+ "tokio",
+]
+
 [[package]]
 name = "tokio-stream"
 version = "0.1.18"
@@ -4073,6 +4464,24 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "trash"
+version = "5.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7602e0c7d66ec2d92a8c917219fbc7894039efa2063b9064260110828a356f46"
+dependencies = [
+ "chrono",
+ "libc",
+ "log",
+ "objc2",
+ "objc2-foundation",
+ "once_cell",
+ "percent-encoding",
+ "scopeguard",
+ "urlencoding",
+ "windows 0.56.0",
+]
+
 [[package]]
 name = "tray-icon"
 version = "0.23.1"
@@ -4095,6 +4504,17 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "tree_magic_mini"
+version = "3.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6"
+dependencies = [
+ "memchr",
+ "nom",
+ "petgraph",
+]
+
 [[package]]
 name = "try-lock"
 version = "0.2.5"
@@ -4191,6 +4611,12 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
 [[package]]
 name = "urlpattern"
 version = "0.3.0"
@@ -4227,6 +4653,12 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
 [[package]]
 name = "version-compare"
 version = "0.2.1"
@@ -4404,6 +4836,76 @@ dependencies = [
  "semver",
 ]
 
+[[package]]
+name = "wayland-backend"
+version = "0.3.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2857dd20b54e916ec7253b3d6b4d5c4d7d4ca2c33c2e11c6c76a99bd8744755d"
+dependencies = [
+ "cc",
+ "downcast-rs",
+ "rustix",
+ "smallvec",
+ "wayland-sys",
+]
+
+[[package]]
+name = "wayland-client"
+version = "0.31.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645c7c96bb74690c3189b5c9cb4ca1627062bb23693a4fad9d8c3de958260144"
+dependencies = [
+ "bitflags 2.11.1",
+ "rustix",
+ "wayland-backend",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols"
+version = "0.32.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "563a85523cade2429938e790815fd7319062103b9f4a2dc806e9b53b95982d8f"
+dependencies = [
+ "bitflags 2.11.1",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols-wlr"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb04e52f7836d7c7976c78ca0250d61e33873c34156a2a1fc9474828ec268234"
+dependencies = [
+ "bitflags 2.11.1",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-scanner"
+version = "0.31.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c324a910fd86ebdc364a3e61ec1f11737d3b1d6c273c0239ee8ff4bc0d24b4a"
+dependencies = [
+ "proc-macro2",
+ "quick-xml 0.39.4",
+ "quote",
+]
+
+[[package]]
+name = "wayland-sys"
+version = "0.31.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be"
+dependencies = [
+ "pkg-config",
+]
+
 [[package]]
 name = "web-sys"
 version = "0.3.99"
@@ -4478,10 +4980,10 @@ checksum = "7130243a7a5b33c54a444e54842e6a9e133de08b5ad7b5861cd8ed9a6a5bc96a"
 dependencies = [
  "webview2-com-macros",
  "webview2-com-sys",
- "windows",
+ "windows 0.61.3",
  "windows-core 0.61.2",
- "windows-implement",
- "windows-interface",
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
 ]
 
 [[package]]
@@ -4502,10 +5004,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "381336cfffd772377d291702245447a5251a2ffa5bad679c99e61bc48bacbf9c"
 dependencies = [
  "thiserror 2.0.18",
- "windows",
+ "windows 0.61.3",
  "windows-core 0.61.2",
 ]
 
+[[package]]
+name = "weezl"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -4552,6 +5060,16 @@ dependencies = [
  "windows-version",
 ]
 
+[[package]]
+name = "windows"
+version = "0.56.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1de69df01bdf1ead2f4ac895dc77c9351aefff65b2f3db429a343f9cbf05e132"
+dependencies = [
+ "windows-core 0.56.0",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows"
 version = "0.61.3"
@@ -4574,14 +5092,26 @@ dependencies = [
  "windows-core 0.61.2",
 ]
 
+[[package]]
+name = "windows-core"
+version = "0.56.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4698e52ed2d08f8658ab0c39512a7c00ee5fe2688c65f8c0a4f06750d729f2a6"
+dependencies = [
+ "windows-implement 0.56.0",
+ "windows-interface 0.56.0",
+ "windows-result 0.1.2",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
 dependencies = [
- "windows-implement",
- "windows-interface",
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
  "windows-link 0.1.3",
  "windows-result 0.3.4",
  "windows-strings 0.4.2",
@@ -4593,8 +5123,8 @@ version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
- "windows-implement",
- "windows-interface",
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
  "windows-link 0.2.1",
  "windows-result 0.4.1",
  "windows-strings 0.5.1",
@@ -4611,6 +5141,17 @@ dependencies = [
  "windows-threading",
 ]
 
+[[package]]
+name = "windows-implement"
+version = "0.56.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6fc35f58ecd95a9b71c4f2329b911016e6bec66b3f2e6a4aad86bd2e99e2f9b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "windows-implement"
 version = "0.60.2"
@@ -4622,6 +5163,17 @@ dependencies = [
  "syn 2.0.117",
 ]
 
+[[package]]
+name = "windows-interface"
+version = "0.56.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08990546bf4edef8f431fa6326e032865f27138718c587dc21bc0265bbcb57cc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "windows-interface"
 version = "0.59.3"
@@ -4655,6 +5207,15 @@ dependencies = [
  "windows-link 0.1.3",
 ]
 
+[[package]]
+name = "windows-result"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-result"
 version = "0.3.4"
@@ -5135,6 +5696,24 @@ dependencies = [
  "wasmparser",
 ]
 
+[[package]]
+name = "wl-clipboard-rs"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9651471a32e87d96ef3a127715382b2d11cc7c8bb9822ded8a7cc94072eb0a3"
+dependencies = [
+ "libc",
+ "log",
+ "os_pipe",
+ "rustix",
+ "thiserror 2.0.18",
+ "tree_magic_mini",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-protocols-wlr",
+]
+
 [[package]]
 name = "writeable"
 version = "0.6.3"
@@ -5179,7 +5758,7 @@ dependencies = [
  "webkit2gtk",
  "webkit2gtk-sys",
  "webview2-com",
- "windows",
+ "windows 0.61.3",
  "windows-core 0.61.2",
  "windows-version",
  "x11-dl",
@@ -5252,6 +5831,26 @@ dependencies = [
  "synstructure",
 ]
 
+[[package]]
+name = "zerocopy"
+version = "0.8.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b065d4f0e55f82fae73202e189638116a87c55ab6b8e6c2721e13dd9d854ad1"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b631b19d36a892ab55420c92dbc83ccd79274f25be714855d3074aa71cab639"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "zerofrom"
 version = "0.1.8"
@@ -5273,6 +5872,12 @@ dependencies = [
  "synstructure",
 ]
 
+[[package]]
+name = "zeroize"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+
 [[package]]
 name = "zerotrie"
 version = "0.2.4"
@@ -5311,3 +5916,18 @@ name = "zmij"
 version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+
+[[package]]
+name = "zune-core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9"
+
+[[package]]
+name = "zune-jpeg"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296"
+dependencies = [
+ "zune-core",
+]
diff --git a/apps/desktop/src-tauri/Cargo.toml b/apps/desktop/src-tauri/Cargo.toml
index 47f7083..9a270f9 100644
--- a/apps/desktop/src-tauri/Cargo.toml
+++ b/apps/desktop/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "tarkov-checker-desktop"
-version = "0.0.0"
+version = "0.1.0"
 description = "Desktop wrapper for tarkov-checker"
 authors = ["tarkov-checker"]
 edition = "2021"
@@ -15,13 +15,40 @@ crate-type = ["staticlib", "cdylib", "rlib"]
 name = "tarkov-checker-desktop"
 path = "src/main.rs"
 
+[[bin]]
+name = "tarkov-checker-headless"
+path = "src/bin/headless.rs"
+
 [build-dependencies]
 tauri-build = { version = "2", features = [] }
 
 [dependencies]
 tauri = { version = "2", features = ["tray-icon"] }
 tauri-plugin-global-shortcut = "2"
+# Standalone global-hotkey registration for the headless backend (run_headless),
+# where there is no Tauri/plugin event loop. In the windowed app the plugin
+# above owns registration; the two never coexist in one process (the plugin
+# installs a process-global GlobalHotKeyEvent handler — see the hotkey rework
+# notes). Same accelerator-string parser the client emits.
+global-hotkey = "0.7"
+# Win32 message pump for the headless hotkey thread: the global-hotkey crate
+# needs a GetMessage/PeekMessage loop on the thread that owns its hidden
+# message window, otherwise WM_HOTKEY is never delivered. Version pinned to
+# match the one global-hotkey already pulls (no extra lockfile entry).
+windows-sys = { version = "0.59", features = ["Win32_UI_WindowsAndMessaging", "Win32_Foundation"] }
 tauri-plugin-window-state = "2"
+# System-clipboard access for the tray "Copy LAN URL" item. Used from Rust
+# (ClipboardExt in commands::copy_lan_url), so the write happens natively and
+# needs no DOM user-gesture — unlike navigator.clipboard, which a tray-menu
+# click can't satisfy.
+tauri-plugin-clipboard-manager = "2"
+# Native Windows toast for the one-time "still running in the tray" hint on the
+# first close-to-tray. We use this directly (not tauri-plugin-notification)
+# because the plugin only stamps the toast's AppUserModelID for installed apps
+# — our portable .exe runs from target/release, so the plugin leaves it as
+# PowerShell's identity. We register our own AUMID + icon (src/notify.rs) and
+# emit with it. Already in the tree transitively; pinning it as a direct dep.
+tauri-winrt-notification = "0.7"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 # Server runtime: filesystem watchers, config storage, registry probes.
@@ -69,11 +96,19 @@ mime_guess = "2"
 # inline. SVG scales without rasterisation and the encoded payload is
 # small (~256 bytes).
 qrcode = { version = "0.14", default-features = false, features = ["svg"] }
+# Sends parsed screenshots to the OS recycle bin (recoverable) when the
+# opt-in "delete after parse" setting is on — see server/screenshots.rs.
+# Recycle bin (not permanent unlink) so an accidental enable is undoable.
+trash = "5"
 # Detects the host's primary LAN IP (first non-loopback IPv4). Used by
 # pairing_qr to build the URL the QR encodes. Multi-NIC hosts can pick
 # the wrong interface (Hyper-V switch, WSL2 vNIC) — the pairing modal
 # surfaces the picked value so the user notices.
 local-ip-address = "0.6"
+# HTTP client for the portable self-updater (GitHub releases/latest +
+# asset download). native-tls = schannel on Windows — avoids rustls/ring,
+# whose build scripts are flaky on this host (see "Windows build quirks").
+reqwest = { version = "0.12", default-features = false, features = ["native-tls", "json"] }
 
 [dev-dependencies]
 # `oneshot` extension on Router for unit-testing handlers in-process —
diff --git a/apps/desktop/src-tauri/build.rs b/apps/desktop/src-tauri/build.rs
index d860e1e..f2b36ea 100644
--- a/apps/desktop/src-tauri/build.rs
+++ b/apps/desktop/src-tauri/build.rs
@@ -1,3 +1,20 @@
 fn main() {
-    tauri_build::build()
+    // ComCtl32 v6 manifest for every linked exe — including the lib unit-test
+    // harness, which tauri-build's embedded manifest never reaches. The lib
+    // statically imports v6-only symbols (SetWindowSubclass etc., via
+    // tray-icon/muda); without a manifest the loader binds comctl32 v5.82 and
+    // the test exe dies at startup with STATUS_ENTRYPOINT_NOT_FOUND.
+    // tauri-build's own manifest (whose entire content is this same dependency
+    // block) is disabled below so the bins don't get a duplicate RT_MANIFEST.
+    println!("cargo:rustc-link-arg=/MANIFEST:EMBED");
+    println!(
+        "cargo:rustc-link-arg=/MANIFESTDEPENDENCY:type='win32' \
+         name='Microsoft.Windows.Common-Controls' version='6.0.0.0' \
+         publicKeyToken='6595b64144ccf1df' language='*' processorArchitecture='*'"
+    );
+    tauri_build::try_build(
+        tauri_build::Attributes::new()
+            .windows_attributes(tauri_build::WindowsAttributes::new_without_app_manifest()),
+    )
+    .expect("failed to run tauri-build");
 }
diff --git a/apps/desktop/src-tauri/capabilities/default.json b/apps/desktop/src-tauri/capabilities/default.json
index 53d48d8..2e618e7 100644
--- a/apps/desktop/src-tauri/capabilities/default.json
+++ b/apps/desktop/src-tauri/capabilities/default.json
@@ -9,6 +9,7 @@
     "core:window:allow-set-ignore-cursor-events",
     "core:window:allow-close",
     "core:window:allow-start-dragging",
+    "core:window:allow-hide",
     "core:window:allow-show",
     "core:window:allow-set-focus",
     "core:webview:allow-set-webview-zoom",
diff --git a/apps/desktop/src-tauri/icons/128x128.png b/apps/desktop/src-tauri/icons/128x128.png
index af8f27c..ded239b 100644
Binary files a/apps/desktop/src-tauri/icons/128x128.png and b/apps/desktop/src-tauri/icons/128x128.png differ
diff --git a/apps/desktop/src-tauri/icons/128x128@2x.png b/apps/desktop/src-tauri/icons/128x128@2x.png
index 9daf2ad..6fb8871 100644
Binary files a/apps/desktop/src-tauri/icons/128x128@2x.png and b/apps/desktop/src-tauri/icons/128x128@2x.png differ
diff --git a/apps/desktop/src-tauri/icons/32x32.png b/apps/desktop/src-tauri/icons/32x32.png
index 3da39f7..3db1516 100644
Binary files a/apps/desktop/src-tauri/icons/32x32.png and b/apps/desktop/src-tauri/icons/32x32.png differ
diff --git a/apps/desktop/src-tauri/icons/64x64.png b/apps/desktop/src-tauri/icons/64x64.png
new file mode 100644
index 0000000..e79f74b
Binary files /dev/null and b/apps/desktop/src-tauri/icons/64x64.png differ
diff --git a/apps/desktop/src-tauri/icons/Square107x107Logo.png b/apps/desktop/src-tauri/icons/Square107x107Logo.png
new file mode 100644
index 0000000..9de7911
Binary files /dev/null and b/apps/desktop/src-tauri/icons/Square107x107Logo.png differ
diff --git a/apps/desktop/src-tauri/icons/Square142x142Logo.png b/apps/desktop/src-tauri/icons/Square142x142Logo.png
new file mode 100644
index 0000000..0a78218
Binary files /dev/null and b/apps/desktop/src-tauri/icons/Square142x142Logo.png differ
diff --git a/apps/desktop/src-tauri/icons/Square150x150Logo.png b/apps/desktop/src-tauri/icons/Square150x150Logo.png
new file mode 100644
index 0000000..6f359d4
Binary files /dev/null and b/apps/desktop/src-tauri/icons/Square150x150Logo.png differ
diff --git a/apps/desktop/src-tauri/icons/Square284x284Logo.png b/apps/desktop/src-tauri/icons/Square284x284Logo.png
new file mode 100644
index 0000000..bf5f70f
Binary files /dev/null and b/apps/desktop/src-tauri/icons/Square284x284Logo.png differ
diff --git a/apps/desktop/src-tauri/icons/Square30x30Logo.png b/apps/desktop/src-tauri/icons/Square30x30Logo.png
new file mode 100644
index 0000000..63a3683
Binary files /dev/null and b/apps/desktop/src-tauri/icons/Square30x30Logo.png differ
diff --git a/apps/desktop/src-tauri/icons/Square310x310Logo.png b/apps/desktop/src-tauri/icons/Square310x310Logo.png
new file mode 100644
index 0000000..ba05c64
Binary files /dev/null and b/apps/desktop/src-tauri/icons/Square310x310Logo.png differ
diff --git a/apps/desktop/src-tauri/icons/Square44x44Logo.png b/apps/desktop/src-tauri/icons/Square44x44Logo.png
new file mode 100644
index 0000000..faed520
Binary files /dev/null and b/apps/desktop/src-tauri/icons/Square44x44Logo.png differ
diff --git a/apps/desktop/src-tauri/icons/Square71x71Logo.png b/apps/desktop/src-tauri/icons/Square71x71Logo.png
new file mode 100644
index 0000000..a4c3db2
Binary files /dev/null and b/apps/desktop/src-tauri/icons/Square71x71Logo.png differ
diff --git a/apps/desktop/src-tauri/icons/Square89x89Logo.png b/apps/desktop/src-tauri/icons/Square89x89Logo.png
new file mode 100644
index 0000000..fec0e26
Binary files /dev/null and b/apps/desktop/src-tauri/icons/Square89x89Logo.png differ
diff --git a/apps/desktop/src-tauri/icons/StoreLogo.png b/apps/desktop/src-tauri/icons/StoreLogo.png
new file mode 100644
index 0000000..a52b383
Binary files /dev/null and b/apps/desktop/src-tauri/icons/StoreLogo.png differ
diff --git a/apps/desktop/src-tauri/icons/icon.icns b/apps/desktop/src-tauri/icons/icon.icns
new file mode 100644
index 0000000..6412fbb
Binary files /dev/null and b/apps/desktop/src-tauri/icons/icon.icns differ
diff --git a/apps/desktop/src-tauri/icons/icon.ico b/apps/desktop/src-tauri/icons/icon.ico
index 99081b3..dec9d49 100644
Binary files a/apps/desktop/src-tauri/icons/icon.ico and b/apps/desktop/src-tauri/icons/icon.ico differ
diff --git a/apps/desktop/src-tauri/icons/icon.png b/apps/desktop/src-tauri/icons/icon.png
new file mode 100644
index 0000000..3404821
Binary files /dev/null and b/apps/desktop/src-tauri/icons/icon.png differ
diff --git a/apps/desktop/src-tauri/src/bin/headless.rs b/apps/desktop/src-tauri/src/bin/headless.rs
new file mode 100644
index 0000000..0e2e0a7
--- /dev/null
+++ b/apps/desktop/src-tauri/src/bin/headless.rs
@@ -0,0 +1,5 @@
+// Headless backend: runs the HTTP server + watchers without the Tauri window.
+// No windows_subsystem attribute — keep a console so logs and Ctrl+C work.
+fn main() {
+    tarkov_checker_desktop_lib::run_headless();
+}
diff --git a/apps/desktop/src-tauri/src/commands.rs b/apps/desktop/src-tauri/src/commands.rs
index 65dda2b..c99844f 100644
--- a/apps/desktop/src-tauri/src/commands.rs
+++ b/apps/desktop/src-tauri/src/commands.rs
@@ -5,33 +5,99 @@ use std::sync::Arc;
 use serde::Serialize;
 use tauri::{AppHandle, State};
 
+use crate::hotkeys::HotkeyController;
 #[cfg(not(debug_assertions))]
 use crate::http_server::LISTEN_PORT;
 use crate::lan::detect_lan_ip;
 use crate::server::config::{ConfigPatch, ConfigStore};
-use crate::server::paths::{self, ResolvedPaths};
+use crate::server::events::ServerEvent;
+use crate::server::hotkeys::{HotkeyConfig, HotkeyPatch, HotkeyStore};
+use crate::server::paths::{self, ConfigResponse};
 use crate::watcher::WatcherSlot;
 
 /// Returns the same shape as the old `GET /api/config`.
 #[tauri::command]
-pub async fn get_config(store: State<'_, Arc<ConfigStore>>) -> Result<ResolvedPaths, String> {
+pub async fn get_config(store: State<'_, Arc<ConfigStore>>) -> Result<ConfigResponse, String> {
     let overrides = store.overrides().await;
-    Ok(paths::resolve(&overrides))
+    Ok(ConfigResponse {
+        paths: paths::resolve(&overrides),
+        delete_screenshots: store.delete_screenshots().await,
+    })
 }
 
 /// `PUT /api/config` analogue. Persists the patch then re-resolves +
-/// re-applies the watcher to honour the new path.
+/// re-applies the watcher to honour the new path / delete-screenshots flag.
 #[tauri::command]
 pub async fn update_config(
     app: AppHandle,
     patch: ConfigPatch,
     store: State<'_, Arc<ConfigStore>>,
     slot: State<'_, Arc<WatcherSlot>>,
-) -> Result<ResolvedPaths, String> {
+) -> Result<ConfigResponse, String> {
     store.apply(patch).await.map_err(|e| e.to_string())?;
+    let delete_screenshots = store.delete_screenshots().await;
+    // Push the new flag to the slot BEFORE re-applying, so the restarted
+    // screenshot watcher clones the up-to-date value.
+    slot.set_delete_screenshots(delete_screenshots);
     let resolved = paths::resolve(&store.overrides().await);
-    crate::watcher::apply_resolved(&app, slot.inner(), &resolved).await;
-    Ok(resolved)
+    crate::watcher::apply_resolved(Some(&app), slot.inner(), &resolved).await;
+    Ok(ConfigResponse {
+        paths: resolved,
+        delete_screenshots,
+    })
+}
+
+/// `GET /api/hotkeys` analogue — the backend-owned combos.
+#[tauri::command]
+pub async fn get_hotkeys(store: State<'_, Arc<HotkeyStore>>) -> Result<HotkeyConfig, String> {
+    Ok(store.get().await)
+}
+
+/// `PUT /api/hotkeys` analogue. Persists the patch then (re)registers the
+/// OS-global hotkeys, reverting any field whose combo can't be claimed.
+/// Returns the effective config.
+#[tauri::command]
+pub async fn update_hotkeys(
+    patch: HotkeyPatch,
+    store: State<'_, Arc<HotkeyStore>>,
+    hotkeys: State<'_, Arc<dyn HotkeyController>>,
+    slot: State<'_, Arc<WatcherSlot>>,
+) -> Result<HotkeyConfig, String> {
+    let merged = store.apply(patch).await?;
+    let controller = hotkeys.inner().clone();
+    let to_apply = merged.clone();
+    let effective = tokio::task::spawn_blocking(move || controller.apply(&to_apply))
+        .await
+        .unwrap_or_else(|_| merged.clone());
+    if effective != merged {
+        store
+            .set(effective.clone())
+            .await
+            .map_err(|e| e.to_string())?;
+    }
+    // Tell the other clients (browser/phone over SSE) the config changed —
+    // `event_sender()` is the same broadcast channel the /events stream serves.
+    let _ = slot.event_sender().send(ServerEvent::Hotkeys {
+        config: effective.clone(),
+    });
+    Ok(effective)
+}
+
+/// Drop all OS hotkey binds while the settings recorder captures a combo, so
+/// the keystroke reaches the webview instead of firing its action.
+#[tauri::command]
+pub async fn suspend_hotkeys(hotkeys: State<'_, Arc<dyn HotkeyController>>) -> Result<(), String> {
+    let controller = hotkeys.inner().clone();
+    let _ = tokio::task::spawn_blocking(move || controller.suspend()).await;
+    Ok(())
+}
+
+/// Re-claim the OS hotkey binds after the recorder finishes.
+#[tauri::command]
+pub async fn resume_hotkeys(hotkeys: State<'_, Arc<dyn HotkeyController>>) -> Result<(), String> {
+    let controller = hotkeys.inner().clone();
+    let _ = tokio::task::spawn_blocking(move || controller.resume()).await;
+    Ok(())
 }
 
 /// Wire shape for [`pairing_qr`]. Both fields are intended for direct
@@ -51,6 +117,19 @@ pub struct PairingQr {
     pub svg: String,
 }
 
+/// Builds the helper's LAN URL (`http://<lan-ip>:<port>/`). Dev serves the
+/// SPA from Vite on :5173; release serves it from the embedded helper on
+/// :47474. Errors with "no LAN IP found" when the host has no non-loopback
+/// IPv4. Shared by `pairing_qr` and `copy_lan_url`.
+fn lan_url() -> Result<String, String> {
+    let ip = detect_lan_ip().ok_or_else(|| "no LAN IP found".to_string())?;
+    #[cfg(debug_assertions)]
+    let port: u16 = 5173;
+    #[cfg(not(debug_assertions))]
+    let port = LISTEN_PORT;
+    Ok(format!("http://{ip}:{port}/"))
+}
+
 /// Builds the LAN URL of the helper plus an inline SVG QR for it.
 /// Called by `PairingModal.vue` on every open so the URL is fresh each
 /// time (LAN IP can change if the user switched Wi-Fi).
@@ -61,13 +140,7 @@ pub struct PairingQr {
 ///   URLs, but surfaced rather than panicked just in case)
 #[tauri::command]
 pub async fn pairing_qr() -> Result<PairingQr, String> {
-    let ip = detect_lan_ip().ok_or_else(|| "no LAN IP found".to_string())?;
-    // Dev: Vite serves the SPA on :5173. Release: helper serves it on :47474.
-    #[cfg(debug_assertions)]
-    let port: u16 = 5173;
-    #[cfg(not(debug_assertions))]
-    let port = LISTEN_PORT;
-    let url = format!("http://{ip}:{port}/");
+    let url = lan_url()?;
     let code = qrcode::QrCode::new(url.as_bytes()).map_err(|e| e.to_string())?;
     let svg = code
         .render::<qrcode::render::svg::Color>()
@@ -75,3 +148,58 @@ pub async fn pairing_qr() -> Result<PairingQr, String> {
         .build();
     Ok(PairingQr { url, svg })
 }
+
+/// Copies the helper's LAN URL to the system clipboard and returns it.
+/// Driven by the tray "Copy LAN URL" item: a native clipboard write that
+/// works without a DOM user-gesture (tray-menu clicks don't grant one, so
+/// `navigator.clipboard` from the webview would be rejected).
+#[tauri::command]
+pub async fn copy_lan_url(app: AppHandle) -> Result<String, String> {
+    use tauri_plugin_clipboard_manager::ClipboardExt;
+    let url = lan_url()?;
+    app.clipboard()
+        .write_text(url.clone())
+        .map_err(|e| e.to_string())?;
+    Ok(url)
+}
+
+/// Shows a native OS notification. Driven once by `useCloseConfirm` on the
+/// first close-to-tray to tell the user the app keeps running in the tray
+/// rather than quitting. Sent from Rust because the window is already hidden
+/// by then, so an in-app toast would no longer be visible. Strings are passed
+/// in pre-localised by the webview. The toast is attributed to this app's
+/// registered AUMID (name + favicon) — see `notify::register_aumid`.
+#[tauri::command]
+pub async fn notify_tray_hint(app: AppHandle, title: String, body: String) -> Result<(), String> {
+    crate::notify::show_toast(&app, &title, &body)
+}
+
+/// Asks GitHub whether a newer release exists. `None` = up to date (or the
+/// repo has no published releases yet). Network failures surface as `Err` —
+/// the webview logs and stays silent, no nagging.
+#[tauri::command]
+pub async fn check_update() -> Result<Option<crate::updater::UpdateInfo>, String> {
+    crate::updater::check().await.map_err(|e| format!("{e:#}"))
+}
+
+/// Portable self-update: re-checks GitHub (the webview never supplies a URL,
+/// so it can't point the updater anywhere else), downloads the new exe, swaps
+/// it in via the rename dance, relaunches and exits. See `updater.rs`.
+#[tauri::command]
+pub async fn install_update(app: AppHandle) -> Result<(), String> {
+    let info = crate::updater::check()
+        .await
+        .map_err(|e| format!("{e:#}"))?
+        .ok_or_else(|| "already up to date".to_string())?;
+    let exe = crate::updater::download_and_swap(&info.download_url)
+        .await
+        .map_err(|e| format!("{e:#}"))?;
+    // --updated: the fresh instance sleeps ~1.5s (main.rs) so this one can
+    // release :47474 and the OS hotkeys before it claims them.
+    std::process::Command::new(exe)
+        .arg("--updated")
+        .spawn()
+        .map_err(|e| e.to_string())?;
+    app.exit(0);
+    Ok(())
+}
diff --git a/apps/desktop/src-tauri/src/hotkeys.rs b/apps/desktop/src-tauri/src/hotkeys.rs
new file mode 100644
index 0000000..c8a68e4
--- /dev/null
+++ b/apps/desktop/src-tauri/src/hotkeys.rs
@@ -0,0 +1,423 @@
+//! OS-global hotkey registration, owned by the backend.
+//!
+//! Two implementations behind one [`HotkeyController`] trait — they are never
+//! used together (the windowed app and the headless backend are mutually
+//! exclusive; both bind :47474):
+//!
+//! * [`TauriHotkeys`] — used by `run()`. Delegates to the already-initialised
+//!   `tauri-plugin-global-shortcut` (its manager lives on Tauri's main thread,
+//!   which pumps Win32 messages). The five action combos are registered via
+//!   the plugin's `GlobalShortcut` API; a process-global handler installed in
+//!   `lib.rs` reads the id→action map this controller maintains and fans the
+//!   press out as a `command` event. The overlay lock combo stays separate
+//!   (client-registered via the plugin's JS API) and is absent from the map.
+//! * [`StandaloneHotkeys`] — used by `run_headless()`. There is no Tauri event
+//!   loop, so it owns a dedicated OS thread that creates a
+//!   `global_hotkey::GlobalHotKeyManager` and runs its own `PeekMessage` pump,
+//!   reading `WM_HOTKEY` directly (no process-global handler involved).
+//!
+//! Combos are accelerator strings parsed by `global_hotkey::hotkey::HotKey`,
+//! whose `id()` is deterministic (`(mods<<16)|key`) — so the registered id can
+//! be mapped back to the action that produced it.
+
+use std::collections::HashMap;
+use std::str::FromStr;
+use std::sync::mpsc;
+use std::sync::Mutex;
+use std::time::Duration;
+
+use global_hotkey::hotkey::HotKey;
+use global_hotkey::GlobalHotKeyManager;
+use tauri::AppHandle;
+use tauri_plugin_global_shortcut::GlobalShortcutExt;
+use tokio::sync::broadcast;
+use windows_sys::Win32::UI::WindowsAndMessaging::{
+    DispatchMessageW, PeekMessageW, TranslateMessage, MSG, PM_REMOVE, WM_HOTKEY,
+};
+
+use crate::server::events::{HotkeyAction, ServerEvent};
+use crate::server::hotkeys::HotkeyConfig;
+
+/// Reconcile registered OS hotkeys with a config, and bracket the recorder's
+/// capture window (suspend = drop all binds so the keystroke reaches the UI,
+/// resume = re-claim from the current config). All methods are synchronous and
+/// may block (the Tauri impl round-trips to the main thread; the standalone
+/// impl round-trips to its pump thread) — call from `spawn_blocking`.
+pub trait HotkeyController: Send + Sync {
+    /// Register `desired`, reverting any field whose combo can't be claimed.
+    /// Returns the effective config (what is actually registered now).
+    fn apply(&self, desired: &HotkeyConfig) -> HotkeyConfig;
+    /// Drop all five OS binds (recorder is capturing).
+    fn suspend(&self);
+    /// Re-claim all five from the current config (recorder finished).
+    fn resume(&self);
+}
+
+/// The five (action, combo) pairs of a config, in stable order.
+fn config_entries(cfg: &HotkeyConfig) -> [(HotkeyAction, &str); 5] {
+    [
+        (HotkeyAction::ZoomIn, cfg.zoom_in.as_str()),
+        (HotkeyAction::ZoomOut, cfg.zoom_out.as_str()),
+        (HotkeyAction::FloorUp, cfg.floor_up.as_str()),
+        (HotkeyAction::FloorDown, cfg.floor_down.as_str()),
+        (HotkeyAction::Airdrop, cfg.airdrop.as_str()),
+    ]
+}
+
+/// (action, old, new) triples for diffing `current` against `desired`.
+fn config_diff(
+    current: &HotkeyConfig,
+    desired: &HotkeyConfig,
+) -> [(HotkeyAction, String, String); 5] {
+    [
+        (
+            HotkeyAction::ZoomIn,
+            current.zoom_in.clone(),
+            desired.zoom_in.clone(),
+        ),
+        (
+            HotkeyAction::ZoomOut,
+            current.zoom_out.clone(),
+            desired.zoom_out.clone(),
+        ),
+        (
+            HotkeyAction::FloorUp,
+            current.floor_up.clone(),
+            desired.floor_up.clone(),
+        ),
+        (
+            HotkeyAction::FloorDown,
+            current.floor_down.clone(),
+            desired.floor_down.clone(),
+        ),
+        (
+            HotkeyAction::Airdrop,
+            current.airdrop.clone(),
+            desired.airdrop.clone(),
+        ),
+    ]
+}
+
+fn config_from_pairs(pairs: &[(HotkeyAction, String)]) -> HotkeyConfig {
+    let mut cfg = HotkeyConfig::default();
+    for (action, combo) in pairs {
+        match action {
+            HotkeyAction::ZoomIn => cfg.zoom_in = combo.clone(),
+            HotkeyAction::ZoomOut => cfg.zoom_out = combo.clone(),
+            HotkeyAction::FloorUp => cfg.floor_up = combo.clone(),
+            HotkeyAction::FloorDown => cfg.floor_down = combo.clone(),
+            HotkeyAction::Airdrop => cfg.airdrop = combo.clone(),
+        }
+    }
+    cfg
+}
+
+/// Build the id→action lookup for a config (combos that fail to parse are
+/// skipped — they were validated by the store, so this only drops garbage).
+pub fn action_map(cfg: &HotkeyConfig) -> HashMap<u32, HotkeyAction> {
+    let mut map = HashMap::new();
+    for (action, combo) in config_entries(cfg) {
+        if let Ok(hk) = HotKey::from_str(combo) {
+            map.insert(hk.id(), action);
+        }
+    }
+    map
+}
+
+/// The five combos as accelerator strings, for the plugin Builder.
+pub fn config_combos(cfg: &HotkeyConfig) -> Vec<String> {
+    config_entries(cfg)
+        .iter()
+        .map(|(_, c)| c.to_string())
+        .collect()
+}
+
+// ---------------------------------------------------------------------------
+// Tauri (windowed app) — delegates to tauri-plugin-global-shortcut.
+// ---------------------------------------------------------------------------
+
+pub struct TauriHotkeys {
+    app: AppHandle,
+    /// Shared with the process-global plugin handler installed in `lib.rs`;
+    /// the handler reads it to turn a pressed shortcut id into an action.
+    map: std::sync::Arc<Mutex<HashMap<u32, HotkeyAction>>>,
+    current: Mutex<HotkeyConfig>,
+}
+
+impl TauriHotkeys {
+    /// `map` must already be seeded with `initial`'s ids (the plugin Builder
+    /// registered those combos before the app started — see `lib.rs`).
+    pub fn new(
+        app: AppHandle,
+        map: std::sync::Arc<Mutex<HashMap<u32, HotkeyAction>>>,
+        initial: HotkeyConfig,
+    ) -> Self {
+        Self {
+            app,
+            map,
+            current: Mutex::new(initial),
+        }
+    }
+}
+
+impl HotkeyController for TauriHotkeys {
+    fn apply(&self, desired: &HotkeyConfig) -> HotkeyConfig {
+        let gs = self.app.global_shortcut();
+        let mut map = self.map.lock().expect("hotkey map poisoned");
+        let mut current = self.current.lock().expect("hotkey current poisoned");
+
+        let mut eff: Vec<(HotkeyAction, String)> = Vec::with_capacity(5);
+        for (action, old, new) in config_diff(&current, desired) {
+            if old == new {
+                eff.push((action, new));
+                continue;
+            }
+            let _ = gs.unregister(old.as_str());
+            if let Ok(hk) = HotKey::from_str(&old) {
+                map.remove(&hk.id());
+            }
+            match gs.register(new.as_str()) {
+                Ok(()) => {
+                    if let Ok(hk) = HotKey::from_str(&new) {
+                        map.insert(hk.id(), action);
+                    }
+                    eff.push((action, new));
+                }
+                Err(e) => {
+                    eprintln!("[hotkeys] register '{new}' failed: {e}; keeping '{old}'");
+                    let _ = gs.register(old.as_str());
+                    if let Ok(hk) = HotKey::from_str(&old) {
+                        map.insert(hk.id(), action);
+                    }
+                    eff.push((action, old));
+                }
+            }
+        }
+        let result = config_from_pairs(&eff);
+        *current = result.clone();
+        result
+    }
+
+    fn suspend(&self) {
+        let gs = self.app.global_shortcut();
+        let mut map = self.map.lock().expect("hotkey map poisoned");
+        let current = self.current.lock().expect("hotkey current poisoned");
+        for (_, combo) in config_entries(&current) {
+            let _ = gs.unregister(combo);
+        }
+        map.clear();
+    }
+
+    fn resume(&self) {
+        let gs = self.app.global_shortcut();
+        let mut map = self.map.lock().expect("hotkey map poisoned");
+        let current = self.current.lock().expect("hotkey current poisoned");
+        map.clear();
+        for (action, combo) in config_entries(&current) {
+            match gs.register(combo) {
+                Ok(()) => {
+                    if let Ok(hk) = HotKey::from_str(combo) {
+                        map.insert(hk.id(), action);
+                    }
+                }
+                Err(e) => eprintln!("[hotkeys] resume register '{combo}' failed: {e}"),
+            }
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Standalone (headless backend) — own thread + Win32 message pump.
+// ---------------------------------------------------------------------------
+
+enum ReqKind {
+    Apply(HotkeyConfig),
+    Suspend,
+    Resume,
+}
+
+struct HotkeyRequest {
+    kind: ReqKind,
+    reply: mpsc::Sender<HotkeyConfig>,
+}
+
+pub struct StandaloneHotkeys {
+    req_tx: mpsc::Sender<HotkeyRequest>,
+}
+
+impl StandaloneHotkeys {
+    pub fn spawn(event_tx: broadcast::Sender<ServerEvent>, initial: HotkeyConfig) -> Self {
+        let (req_tx, req_rx) = mpsc::channel::<HotkeyRequest>();
+        std::thread::Builder::new()
+            .name("global-hotkeys".into())
+            .spawn(move || pump_thread(event_tx, initial, req_rx))
+            .expect("spawn global-hotkeys thread");
+        Self { req_tx }
+    }
+
+    fn request(&self, kind: ReqKind, fallback: HotkeyConfig) -> HotkeyConfig {
+        let (reply_tx, reply_rx) = mpsc::channel();
+        if self
+            .req_tx
+            .send(HotkeyRequest {
+                kind,
+                reply: reply_tx,
+            })
+            .is_err()
+        {
+            return fallback; // pump thread gone
+        }
+        reply_rx
+            .recv_timeout(Duration::from_secs(2))
+            .unwrap_or(fallback)
+    }
+}
+
+impl HotkeyController for StandaloneHotkeys {
+    fn apply(&self, desired: &HotkeyConfig) -> HotkeyConfig {
+        self.request(ReqKind::Apply(desired.clone()), desired.clone())
+    }
+    fn suspend(&self) {
+        let _ = self.request(ReqKind::Suspend, HotkeyConfig::default());
+    }
+    fn resume(&self) {
+        let _ = self.request(ReqKind::Resume, HotkeyConfig::default());
+    }
+}
+
+fn register_all(
+    manager: &GlobalHotKeyManager,
+    cfg: &HotkeyConfig,
+    registered: &mut HashMap<u32, HotkeyAction>,
+) {
+    for (action, combo) in config_entries(cfg) {
+        if let Ok(hk) = HotKey::from_str(combo) {
+            match manager.register(hk) {
+                Ok(()) => {
+                    registered.insert(hk.id(), action);
+                }
+                Err(e) => eprintln!("[hotkeys] register '{combo}' failed: {e}"),
+            }
+        }
+    }
+}
+
+fn unregister_cfg(
+    manager: &GlobalHotKeyManager,
+    cfg: &HotkeyConfig,
+    registered: &mut HashMap<u32, HotkeyAction>,
+) {
+    for (_, combo) in config_entries(cfg) {
+        if let Ok(hk) = HotKey::from_str(combo) {
+            let _ = manager.unregister(hk);
+            registered.remove(&hk.id());
+        }
+    }
+}
+
+fn reconcile(
+    manager: &GlobalHotKeyManager,
+    current: &HotkeyConfig,
+    desired: &HotkeyConfig,
+    registered: &mut HashMap<u32, HotkeyAction>,
+) -> HotkeyConfig {
+    let mut eff: Vec<(HotkeyAction, String)> = Vec::with_capacity(5);
+    for (action, old, new) in config_diff(current, desired) {
+        if old == new {
+            eff.push((action, new));
+            continue;
+        }
+        if let Ok(hk) = HotKey::from_str(&old) {
+            let _ = manager.unregister(hk);
+            registered.remove(&hk.id());
+        }
+        let registered_new = HotKey::from_str(&new)
+            .ok()
+            .and_then(|hk| manager.register(hk).ok().map(|()| hk));
+        match registered_new {
+            Some(hk) => {
+                registered.insert(hk.id(), action);
+                eff.push((action, new));
+            }
+            None => {
+                eprintln!("[hotkeys] register '{new}' failed; keeping '{old}'");
+                if let Ok(hk) = HotKey::from_str(&old) {
+                    if manager.register(hk).is_ok() {
+                        registered.insert(hk.id(), action);
+                    }
+                }
+                eff.push((action, old));
+            }
+        }
+    }
+    config_from_pairs(&eff)
+}
+
+fn pump_thread(
+    event_tx: broadcast::Sender<ServerEvent>,
+    initial: HotkeyConfig,
+    req_rx: mpsc::Receiver<HotkeyRequest>,
+) {
+    let manager = match GlobalHotKeyManager::new() {
+        Ok(m) => m,
+        Err(e) => {
+            eprintln!("[hotkeys] GlobalHotKeyManager::new failed: {e}");
+            return;
+        }
+    };
+
+    let mut current = initial;
+    let mut suspended = false;
+    let mut registered: HashMap<u32, HotkeyAction> = HashMap::new();
+    register_all(&manager, &current, &mut registered);
+    eprintln!(
+        "[hotkeys] headless global hotkeys registered ({} combos)",
+        registered.len()
+    );
+
+    let mut msg: MSG = unsafe { std::mem::zeroed() };
+    loop {
+        // Drain Win32 messages so WM_HOTKEY is observed. We read the hotkey id
+        // straight off the message (wParam == HotKey::id()) instead of routing
+        // through the crate's process-global handler.
+        unsafe {
+            while PeekMessageW(&mut msg, std::ptr::null_mut(), 0, 0, PM_REMOVE) != 0 {
+                if msg.message == WM_HOTKEY {
+                    let id = msg.wParam as u32;
+                    if let Some(&action) = registered.get(&id) {
+                        let _ = event_tx.send(ServerEvent::Command { action });
+                    }
+                } else {
+                    TranslateMessage(&msg);
+                    DispatchMessageW(&msg);
+                }
+            }
+        }
+
+        match req_rx.recv_timeout(Duration::from_millis(50)) {
+            Ok(req) => {
+                match req.kind {
+                    ReqKind::Apply(desired) => {
+                        if suspended {
+                            current = desired;
+                        } else {
+                            current = reconcile(&manager, &current, &desired, &mut registered);
+                        }
+                    }
+                    ReqKind::Suspend => {
+                        unregister_cfg(&manager, &current, &mut registered);
+                        suspended = true;
+                    }
+                    ReqKind::Resume => {
+                        suspended = false;
+                        registered.clear();
+                        register_all(&manager, &current, &mut registered);
+                    }
+                }
+                let _ = req.reply.send(current.clone());
+            }
+            Err(mpsc::RecvTimeoutError::Timeout) => {}
+            Err(mpsc::RecvTimeoutError::Disconnected) => break,
+        }
+    }
+}
diff --git a/apps/desktop/src-tauri/src/http_server.rs b/apps/desktop/src-tauri/src/http_server.rs
index 74f043c..afd894f 100644
--- a/apps/desktop/src-tauri/src/http_server.rs
+++ b/apps/desktop/src-tauri/src/http_server.rs
@@ -5,6 +5,8 @@ use std::net::SocketAddr;
 use std::sync::Arc;
 use std::time::Duration;
 
+#[cfg(not(debug_assertions))]
+use axum::http::Uri;
 use axum::{
     extract::State,
     http::{header, HeaderValue, Method, StatusCode},
@@ -12,11 +14,9 @@ use axum::{
         sse::{Event, KeepAlive, Sse},
         IntoResponse, Json, Response,
     },
-    routing::get,
+    routing::{get, post},
     Extension, Router,
 };
-#[cfg(not(debug_assertions))]
-use axum::http::Uri;
 use futures_util::stream::{Stream, StreamExt};
 use serde::Serialize;
 use tauri::AppHandle;
@@ -24,9 +24,11 @@ use tokio::sync::broadcast;
 use tokio_stream::wrappers::{errors::BroadcastStreamRecvError, BroadcastStream};
 use tower_http::cors::{AllowOrigin, CorsLayer};
 
+use crate::hotkeys::HotkeyController;
 use crate::server::config::{ConfigPatch, ConfigStore};
 use crate::server::events::ServerEvent;
-use crate::server::paths::{self, ResolvedPaths};
+use crate::server::hotkeys::{HotkeyConfig, HotkeyPatch, HotkeyStore};
+use crate::server::paths::{self, ConfigResponse};
 use crate::watcher::{self, WatcherSlot};
 
 pub const LISTEN_PORT: u16 = 47474;
@@ -41,7 +43,9 @@ const ALLOWED_ORIGINS: &[&str] = &[
 pub struct Deps {
     pub config_store: Arc<ConfigStore>,
     pub watcher_slot: Arc<WatcherSlot>,
-    pub app_handle: AppHandle,
+    pub app_handle: Option<AppHandle>,
+    pub hotkey_store: Arc<HotkeyStore>,
+    pub hotkeys: Arc<dyn HotkeyController>,
 }
 
 /// Per-server shared state. Cheap to clone (Arc all the way down).
@@ -60,6 +64,10 @@ struct AppState {
     /// Held here (not inside WatcherSlot directly) so the HTTP handler
     /// can grab a clone without indirecting through the slot.
     event_tx: broadcast::Sender<ServerEvent>,
+    /// Backend-owned global hotkey combos (persisted in hotkeys.json).
+    hotkey_store: Arc<HotkeyStore>,
+    /// Registers/reconciles the OS-global hotkeys from `hotkey_store`.
+    hotkeys: Arc<dyn HotkeyController>,
 }
 
 #[derive(Serialize)]
@@ -89,9 +97,12 @@ struct ConfigError {
 /// plus the `source` and `exists` flags per slot. Same JSON the Tauri
 /// `get_config` IPC command returns, so a browser frontend reads the
 /// same shape as the webview.
-async fn get_config_http(State(state): State<AppState>) -> Json<ResolvedPaths> {
+async fn get_config_http(State(state): State<AppState>) -> Json<ConfigResponse> {
     let overrides = state.config_store.overrides().await;
-    Json(paths::resolve(&overrides))
+    Json(ConfigResponse {
+        paths: paths::resolve(&overrides),
+        delete_screenshots: state.config_store.delete_screenshots().await,
+    })
 }
 
 /// `GET /events` — Server-Sent Events stream of `ServerEvent`s. One JSON
@@ -138,9 +149,9 @@ async fn events_sse(
 /// supported: \\server\share"}`).
 async fn put_config_http(
     State(state): State<AppState>,
-    Extension(app): Extension<AppHandle>,
+    Extension(app): Extension<Option<AppHandle>>,
     Json(patch): Json<ConfigPatch>,
-) -> Result<Json<ResolvedPaths>, (StatusCode, Json<ConfigError>)> {
+) -> Result<Json<ConfigResponse>, (StatusCode, Json<ConfigError>)> {
     state.config_store.apply(patch).await.map_err(|e| {
         (
             StatusCode::BAD_REQUEST,
@@ -149,9 +160,72 @@ async fn put_config_http(
             }),
         )
     })?;
+    let delete_screenshots = state.config_store.delete_screenshots().await;
+    // Update the slot before re-applying so the restarted watcher sees it.
+    state
+        .watcher_slot
+        .set_delete_screenshots(delete_screenshots);
     let resolved = paths::resolve(&state.config_store.overrides().await);
-    watcher::apply_resolved(&app, &state.watcher_slot, &resolved).await;
-    Ok(Json(resolved))
+    watcher::apply_resolved(app.as_ref(), &state.watcher_slot, &resolved).await;
+    Ok(Json(ConfigResponse {
+        paths: resolved,
+        delete_screenshots,
+    }))
+}
+
+/// `GET /api/hotkeys` — the backend-owned combos. Same JSON the Tauri
+/// `get_hotkeys` IPC command returns.
+async fn get_hotkeys_http(State(state): State<AppState>) -> Json<HotkeyConfig> {
+    Json(state.hotkey_store.get().await)
+}
+
+/// `PUT /api/hotkeys` — validate + persist the patch, then (re)register the
+/// OS-global hotkeys. If a combo can't be claimed the manager reverts that
+/// field; the *effective* config is persisted and returned so the client
+/// snaps the recorder back. Unparseable combo → 400.
+async fn put_hotkeys_http(
+    State(state): State<AppState>,
+    Json(patch): Json<HotkeyPatch>,
+) -> Result<Json<HotkeyConfig>, (StatusCode, Json<ConfigError>)> {
+    let merged = state
+        .hotkey_store
+        .apply(patch)
+        .await
+        .map_err(|error| (StatusCode::BAD_REQUEST, Json(ConfigError { error })))?;
+
+    // Registration blocks (round-trips to the main / pump thread); keep it off
+    // the async worker.
+    let hotkeys = state.hotkeys.clone();
+    let to_apply = merged.clone();
+    let effective = tokio::task::spawn_blocking(move || hotkeys.apply(&to_apply))
+        .await
+        .unwrap_or(merged.clone());
+
+    // Persist the revert if a field couldn't be registered.
+    if effective != merged {
+        if let Err(err) = state.hotkey_store.set(effective.clone()).await {
+            eprintln!("[hotkeys] persist effective config failed: {err:#}");
+        }
+    }
+    // Notify the other clients (browser/phone over SSE) so their view re-syncs.
+    let _ = state.event_tx.send(ServerEvent::Hotkeys {
+        config: effective.clone(),
+    });
+    Ok(Json(effective))
+}
+
+/// `POST /api/hotkeys/suspend` — drop all OS binds while a recorder captures.
+async fn suspend_hotkeys_http(State(state): State<AppState>) -> StatusCode {
+    let hotkeys = state.hotkeys.clone();
+    let _ = tokio::task::spawn_blocking(move || hotkeys.suspend()).await;
+    StatusCode::NO_CONTENT
+}
+
+/// `POST /api/hotkeys/resume` — re-claim the combos after capture finishes.
+async fn resume_hotkeys_http(State(state): State<AppState>) -> StatusCode {
+    let hotkeys = state.hotkeys.clone();
+    let _ = tokio::task::spawn_blocking(move || hotkeys.resume()).await;
+    StatusCode::NO_CONTENT
 }
 
 // Release-only: bake apps/client/dist/ into the .exe. In dev the SPA is
@@ -196,7 +270,7 @@ fn cors_layer() -> CorsLayer {
 
     CorsLayer::new()
         .allow_origin(AllowOrigin::list(origins))
-        .allow_methods([Method::GET, Method::PUT, Method::OPTIONS])
+        .allow_methods([Method::GET, Method::PUT, Method::POST, Method::OPTIONS])
         .allow_headers([header::CONTENT_TYPE])
         // Chrome's Private Network Access policy: a public-origin page
         // (HTTPS on internet) hitting a private IP (127.0.0.1) needs an
@@ -213,6 +287,9 @@ fn router(state: AppState) -> Router {
     Router::new()
         .route("/api/ping", get(ping))
         .route("/api/config", get(get_config_http).put(put_config_http))
+        .route("/api/hotkeys", get(get_hotkeys_http).put(put_hotkeys_http))
+        .route("/api/hotkeys/suspend", post(suspend_hotkeys_http))
+        .route("/api/hotkeys/resume", post(resume_hotkeys_http))
         .route("/events", get(events_sse))
         .with_state(state)
         // SPA fallback MUST come after the API/SSE routes and BEFORE
@@ -233,6 +310,8 @@ pub fn spawn(deps: Deps) {
         config_store: deps.config_store,
         watcher_slot: deps.watcher_slot,
         event_tx,
+        hotkey_store: deps.hotkey_store,
+        hotkeys: deps.hotkeys,
     };
     let app_handle = deps.app_handle;
     tauri::async_runtime::spawn(async move {
@@ -261,27 +340,46 @@ mod tests {
     use axum::http::Request as HttpRequest;
     use tower::ServiceExt;
 
-    async fn test_state() -> AppState {
-        // ConfigStore wants a file path it can write to. Tests use a
-        // per-process tmp file; the file may not exist yet (load returns
-        // empty state in that case).
-        let tmp = std::env::temp_dir().join(format!(
-            "tarkov-checker-test-{}-{}.json",
+    /// No-op hotkey controller — the route tests never register real OS
+    /// hotkeys, they only exercise the HTTP wiring + store.
+    struct NoopHotkeys;
+    impl HotkeyController for NoopHotkeys {
+        fn apply(&self, desired: &HotkeyConfig) -> HotkeyConfig {
+            desired.clone()
+        }
+        fn suspend(&self) {}
+        fn resume(&self) {}
+    }
+
+    fn tmp_json(tag: &str) -> std::path::PathBuf {
+        std::env::temp_dir().join(format!(
+            "tarkov-checker-test-{tag}-{}-{}.json",
             std::process::id(),
             std::time::SystemTime::now()
                 .duration_since(std::time::UNIX_EPOCH)
                 .unwrap_or_default()
                 .as_nanos(),
-        ));
-        let store = ConfigStore::load(tmp)
+        ))
+    }
+
+    async fn test_state() -> AppState {
+        // ConfigStore wants a file path it can write to. Tests use a
+        // per-process tmp file; the file may not exist yet (load returns
+        // empty state in that case).
+        let store = ConfigStore::load(tmp_json("config"))
             .await
             .expect("test config store should load");
+        let hotkey_store = HotkeyStore::load(tmp_json("hotkeys"))
+            .await
+            .expect("test hotkey store should load");
         let watcher_slot = Arc::new(WatcherSlot::default());
         let event_tx = watcher_slot.event_sender();
         AppState {
             config_store: Arc::new(store),
             watcher_slot,
             event_tx,
+            hotkey_store: Arc::new(hotkey_store),
+            hotkeys: Arc::new(NoopHotkeys),
         }
     }
 
@@ -343,6 +441,83 @@ mod tests {
         assert!(body.contains("screenshotsDir"), "body: {body}");
     }
 
+    // -----------------------------------------------------------------
+    // /api/hotkeys — backend-owned combos
+    // -----------------------------------------------------------------
+
+    #[tokio::test]
+    async fn get_hotkeys_returns_defaults() {
+        let response = test_router(test_state().await)
+            .oneshot(
+                HttpRequest::builder()
+                    .uri("/api/hotkeys")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(response.status(), StatusCode::OK);
+        let body = body_text(response).await;
+        assert!(body.contains("\"zoomIn\""), "body: {body}");
+        assert!(body.contains("\"airdrop\""), "body: {body}");
+    }
+
+    #[tokio::test]
+    async fn put_hotkeys_applies_valid_patch() {
+        // Unlike PUT /api/config, the hotkeys PUT needs no Extension<AppHandle>
+        // (NoopHotkeys in test state), so it runs to completion here.
+        let response = test_router(test_state().await)
+            .oneshot(
+                HttpRequest::builder()
+                    .method(Method::PUT)
+                    .uri("/api/hotkeys")
+                    .header(header::CONTENT_TYPE, "application/json")
+                    .body(Body::from(r#"{"zoomIn":"CommandOrControl+Alt+Z"}"#))
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(response.status(), StatusCode::OK);
+        let body = body_text(response).await;
+        assert!(
+            body.contains("CommandOrControl+Alt+Z"),
+            "effective config should echo the new combo: {body}"
+        );
+    }
+
+    #[tokio::test]
+    async fn put_hotkeys_rejects_unparseable_combo() {
+        let response = test_router(test_state().await)
+            .oneshot(
+                HttpRequest::builder()
+                    .method(Method::PUT)
+                    .uri("/api/hotkeys")
+                    .header(header::CONTENT_TYPE, "application/json")
+                    .body(Body::from(r#"{"airdrop":"not+a+real+key"}"#))
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+    }
+
+    #[tokio::test]
+    async fn suspend_resume_hotkeys_return_no_content() {
+        for path in ["/api/hotkeys/suspend", "/api/hotkeys/resume"] {
+            let response = test_router(test_state().await)
+                .oneshot(
+                    HttpRequest::builder()
+                        .method(Method::POST)
+                        .uri(path)
+                        .body(Body::empty())
+                        .unwrap(),
+                )
+                .await
+                .unwrap();
+            assert_eq!(response.status(), StatusCode::NO_CONTENT, "path: {path}");
+        }
+    }
+
     // -----------------------------------------------------------------
     // /events — SSE smoke test (handler opens, sends correct headers)
     // -----------------------------------------------------------------
@@ -382,6 +557,9 @@ mod tests {
                     .header(header::ORIGIN, "http://localhost:5173")
                     .header("access-control-request-method", "PUT")
                     .header("access-control-request-headers", "content-type")
+                    // Chrome sends this on public→private preflights; the
+                    // allow header below is only emitted in response to it.
+                    .header("access-control-request-private-network", "true")
                     .body(Body::empty())
                     .unwrap(),
             )
diff --git a/apps/desktop/src-tauri/src/lan.rs b/apps/desktop/src-tauri/src/lan.rs
index 5256906..bbeca01 100644
--- a/apps/desktop/src-tauri/src/lan.rs
+++ b/apps/desktop/src-tauri/src/lan.rs
@@ -21,11 +21,11 @@ const VIRTUAL_INTERFACE_HINTS: &[&str] = &[
     "wsl",
     "docker",
     "vmware",
-    "vbox",      // VirtualBox
+    "vbox", // VirtualBox
     "virtualbox",
     "loopback",
-    "tap-",      // OpenVPN TAP adapters
-    "tun",       // OpenVPN TUN
+    "tap-", // OpenVPN TAP adapters
+    "tun",  // OpenVPN TUN
 ];
 
 /// Best-guess primary LAN IP of the host. Returns `None` if there is
diff --git a/apps/desktop/src-tauri/src/lib.rs b/apps/desktop/src-tauri/src/lib.rs
index 9b56125..b189016 100644
--- a/apps/desktop/src-tauri/src/lib.rs
+++ b/apps/desktop/src-tauri/src/lib.rs
@@ -1,32 +1,104 @@
 mod commands;
+mod hotkeys;
 mod http_server;
 mod lan;
+mod notify;
 mod server;
+mod updater;
 mod watcher;
 
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
-use tauri::Manager;
+use global_hotkey::hotkey::HotKey;
+use std::str::FromStr;
+use tauri::{Emitter, Manager};
+use tauri_plugin_global_shortcut::ShortcutState;
 
+use crate::hotkeys::{HotkeyController, StandaloneHotkeys, TauriHotkeys};
 use crate::server::config::{self, ConfigStore};
+use crate::server::events::{self, CommandPayload, ServerEvent};
+use crate::server::hotkeys::HotkeyStore;
 use crate::server::paths;
 use crate::watcher::WatcherSlot;
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
+    // The five forwarded hotkey combos must be known before the plugin is
+    // built (its Builder registers them directly, dodging the
+    // run_on_main_thread deadlock that registering during our own setup hook
+    // would hit). So load the store + seed the id→action map up front.
+    let data_dir = config::data_dir().expect("resolve data dir");
+    std::fs::create_dir_all(&data_dir).expect("create data dir");
+    let hotkey_store = Arc::new(
+        tauri::async_runtime::block_on(HotkeyStore::load(data_dir.join("hotkeys.json")))
+            .expect("load hotkeys.json"),
+    );
+    let hotkey_cfg = tauri::async_runtime::block_on(hotkey_store.get());
+
+    // Shared with the plugin press-handler below AND TauriHotkeys (which
+    // mutates it on re-register). std::sync::Mutex — only held for a map
+    // lookup/swap, no awaits.
+    let action_map = Arc::new(Mutex::new(hotkeys::action_map(&hotkey_cfg)));
+    // Only register combos that actually parse (a hand-corrupted hotkeys.json
+    // shouldn't crash startup); the rest are dropped + logged.
+    let initial_combos: Vec<String> = hotkeys::config_combos(&hotkey_cfg)
+        .into_iter()
+        .filter(|c| HotKey::from_str(c).is_ok())
+        .collect();
+
+    // Created up front so the press-handler can fan presses into the same
+    // broadcast stream the watchers feed; shared with WatcherSlot in setup.
+    let event_tx = events::channel();
+
+    let handler_tx = event_tx.clone();
+    let handler_map = action_map.clone();
+    let shortcut_plugin = tauri_plugin_global_shortcut::Builder::new()
+        .with_shortcuts(initial_combos.iter().map(|s| s.as_str()))
+        .expect("default hotkey combos must parse")
+        .with_handler(move |app, shortcut, event| {
+            // Plugin fires Pressed + Released — act on Pressed only.
+            if event.state != ShortcutState::Pressed {
+                return;
+            }
+            // The lock combo (JS-registered) also reaches this global handler
+            // but isn't in the action map → ignored here, handled client-side.
+            let action = handler_map
+                .lock()
+                .ok()
+                .and_then(|m| m.get(&shortcut.id()).copied());
+            if let Some(action) = action {
+                let _ = handler_tx.send(ServerEvent::Command { action });
+                let _ = app.emit("command", CommandPayload { action });
+            }
+        })
+        .build();
+
     tauri::Builder::default()
-        .plugin(tauri_plugin_global_shortcut::Builder::new().build())
+        .plugin(shortcut_plugin)
         .plugin(tauri_plugin_window_state::Builder::default().build())
+        .plugin(tauri_plugin_clipboard_manager::init())
         .invoke_handler(tauri::generate_handler![
             commands::get_config,
             commands::update_config,
+            commands::get_hotkeys,
+            commands::update_hotkeys,
+            commands::suspend_hotkeys,
+            commands::resume_hotkeys,
             commands::pairing_qr,
+            commands::copy_lan_url,
+            commands::notify_tray_hint,
+            commands::check_update,
+            commands::install_update,
         ])
-        .setup(|app| {
+        .setup(move |app| {
             let app_handle = app.handle().clone();
 
-            let data_dir = config::data_dir()?;
-            std::fs::create_dir_all(&data_dir)?;
+            // Sweep the `.old.exe` a previous self-update left behind.
+            updater::cleanup_old();
+
+            // Register our AppUserModelID (name + favicon) so the tray-hint
+            // toast is attributed to this app instead of PowerShell.
+            notify::register_aumid(&app_handle, &data_dir);
 
             // Block-on the async load — we want the config ready before
             // the webview starts running its onMounted hooks. Tiny JSON;
@@ -35,15 +107,29 @@ pub fn run() {
                 tauri::async_runtime::block_on(ConfigStore::load(data_dir.join("config.json")))?;
             let store = Arc::new(store);
 
-            // Arc-wrap up front so the same instance can be reached via
-            // Tauri state (for IPC commands) and via http_server::Deps.
-            // Cheap clones, no double state to keep in sync.
-            let slot = Arc::new(WatcherSlot::default());
+            // Reuse the up-front broadcast sender so hotkey `Command` events
+            // and watcher events share one stream.
+            let slot = Arc::new(WatcherSlot::with_sender(event_tx.clone()));
+            slot.set_delete_screenshots(tauri::async_runtime::block_on(store.delete_screenshots()));
             let resolved = paths::resolve(&tauri::async_runtime::block_on(store.overrides()));
-            tauri::async_runtime::block_on(watcher::apply_resolved(&app_handle, &slot, &resolved));
+            tauri::async_runtime::block_on(watcher::apply_resolved(
+                Some(&app_handle),
+                &slot,
+                &resolved,
+            ));
+
+            // Hotkey controller shares the same id→action map the plugin
+            // handler reads, so a PUT re-registration keeps them in lockstep.
+            let hotkeys: Arc<dyn HotkeyController> = Arc::new(TauriHotkeys::new(
+                app_handle.clone(),
+                action_map.clone(),
+                hotkey_cfg.clone(),
+            ));
 
             app.manage(store.clone());
             app.manage(slot.clone());
+            app.manage(hotkey_store.clone());
+            app.manage(hotkeys.clone());
 
             // Companion HTTP server. Spawned independently of the
             // watcher pipeline — a bind failure does not block the
@@ -51,11 +137,127 @@ pub fn run() {
             http_server::spawn(http_server::Deps {
                 config_store: store,
                 watcher_slot: slot,
-                app_handle: app_handle.clone(),
+                app_handle: Some(app_handle.clone()),
+                hotkey_store: hotkey_store.clone(),
+                hotkeys: hotkeys.clone(),
             });
 
+            // Clamp restored window onto a visible monitor (handles 2K→FHD moves).
+            if let Some(win) = app.get_webview_window("main") {
+                clamp_window_to_monitor(&win);
+            }
+
             Ok(())
         })
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }
+
+/// Run only the HTTP server + filesystem watchers (no Tauri window). Lets a
+/// browser / LAN client use the helper without launching the overlay.
+pub fn run_headless() {
+    tauri::async_runtime::block_on(async {
+        let data_dir = match config::data_dir() {
+            Ok(d) => d,
+            Err(e) => {
+                eprintln!("[headless] config dir: {e:#}");
+                return;
+            }
+        };
+        if let Err(e) = std::fs::create_dir_all(&data_dir) {
+            eprintln!("[headless] create data dir: {e:#}");
+            return;
+        }
+        let store = match ConfigStore::load(data_dir.join("config.json")).await {
+            Ok(s) => Arc::new(s),
+            Err(e) => {
+                eprintln!("[headless] load config: {e:#}");
+                return;
+            }
+        };
+        let hotkey_store = match HotkeyStore::load(data_dir.join("hotkeys.json")).await {
+            Ok(s) => Arc::new(s),
+            Err(e) => {
+                eprintln!("[headless] load hotkeys: {e:#}");
+                return;
+            }
+        };
+        // One broadcast stream shared by the watchers and the hotkey thread.
+        let event_tx = events::channel();
+        let slot = Arc::new(WatcherSlot::with_sender(event_tx.clone()));
+        slot.set_delete_screenshots(store.delete_screenshots().await);
+        let resolved = paths::resolve(&store.overrides().await);
+        watcher::apply_resolved(None, &slot, &resolved).await;
+
+        // No Tauri/plugin event loop here, so use the standalone manager —
+        // it runs its own Win32 message pump on a dedicated thread.
+        let hotkey_cfg = hotkey_store.get().await;
+        let hotkeys: Arc<dyn HotkeyController> =
+            Arc::new(StandaloneHotkeys::spawn(event_tx.clone(), hotkey_cfg));
+
+        http_server::spawn(http_server::Deps {
+            config_store: store,
+            watcher_slot: slot,
+            app_handle: None,
+            hotkey_store,
+            hotkeys,
+        });
+        eprintln!("[headless] tarkov-checker backend up — http://0.0.0.0:47474 (Ctrl+C to stop)");
+        std::future::pending::<()>().await;
+    });
+}
+
+/// Reposition the window if the window-state plugin restored coordinates that
+/// land off every current monitor (monitor layout changed between sessions).
+fn clamp_window_to_monitor(window: &tauri::WebviewWindow) {
+    const MIN_OVERLAP: i32 = 48;
+
+    let Ok(pos) = window.outer_position() else {
+        return;
+    };
+    let Ok(size) = window.outer_size() else {
+        return;
+    };
+    let Ok(monitors) = window.available_monitors() else {
+        return;
+    };
+
+    if monitors.is_empty() {
+        return;
+    }
+
+    let wx1 = pos.x;
+    let wy1 = pos.y;
+    let wx2 = wx1 + size.width as i32;
+    let wy2 = wy1 + size.height as i32;
+
+    let on_screen = monitors.iter().any(|m| {
+        let mx1 = m.position().x;
+        let my1 = m.position().y;
+        let mx2 = mx1 + m.size().width as i32;
+        let my2 = my1 + m.size().height as i32;
+
+        let ix = (wx2.min(mx2) - wx1.max(mx1)).max(0);
+        let iy = (wy2.min(my2) - wy1.max(my1)).max(0);
+        ix >= MIN_OVERLAP && iy >= MIN_OVERLAP
+    });
+
+    if on_screen {
+        return;
+    }
+
+    // Pick primary → first available → current.
+    let target = window
+        .primary_monitor()
+        .ok()
+        .flatten()
+        .or_else(|| monitors.into_iter().next())
+        .or_else(|| window.current_monitor().ok().flatten());
+
+    if let Some(m) = target {
+        const MARGIN: i32 = 40;
+        let nx = m.position().x + MARGIN;
+        let ny = m.position().y + MARGIN;
+        let _ = window.set_position(tauri::PhysicalPosition::new(nx, ny));
+    }
+}
diff --git a/apps/desktop/src-tauri/src/main.rs b/apps/desktop/src-tauri/src/main.rs
index 3a329b8..558d446 100644
--- a/apps/desktop/src-tauri/src/main.rs
+++ b/apps/desktop/src-tauri/src/main.rs
@@ -2,5 +2,10 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 fn main() {
+    // Relaunch-after-self-update: give the old instance time to exit and
+    // release :47474 + the OS hotkeys before this one claims them.
+    if std::env::args().any(|a| a == "--updated") {
+        std::thread::sleep(std::time::Duration::from_millis(1500));
+    }
     tarkov_checker_desktop_lib::run()
 }
diff --git a/apps/desktop/src-tauri/src/notify.rs b/apps/desktop/src-tauri/src/notify.rs
new file mode 100644
index 0000000..329cc86
--- /dev/null
+++ b/apps/desktop/src-tauri/src/notify.rs
@@ -0,0 +1,71 @@
+//! Windows toast notifications attributed to this app (its name + icon)
+//! rather than PowerShell.
+//!
+//! `tauri-plugin-notification` only stamps the toast's AppUserModelID when the
+//! exe runs from somewhere other than `target/{debug,release}`. Our portable
+//! .exe ships straight out of `target/release` (and dev runs from
+//! `target/debug`), so the plugin always skips it and notify-rust falls back
+//! to its PowerShell identity — which is what shows up as the toast's author.
+//!
+//! We sidestep that by registering our OWN AppUserModelID in HKCU (with a
+//! DisplayName + IconUri) and emitting the toast through
+//! `tauri-winrt-notification` with that id. No installer / Start-Menu shortcut
+//! required, so it works for the portable build.
+
+use std::path::{Path, PathBuf};
+
+use tauri::AppHandle;
+use tauri_winrt_notification::Toast;
+
+// The app mark — the same one the browser build shows — baked in at compile
+// time from icons/128x128.png (regenerated from favicon.svg via `tauri icon`).
+// Written to disk on launch so the AUMID's IconUri can point at a real file.
+const ICON_BYTES: &[u8] = include_bytes!("../icons/128x128.png");
+
+/// Registers `HKCU\Software\Classes\AppUserModelId\<identifier>` with a
+/// DisplayName + IconUri so Windows shows this app's name and icon on toasts
+/// instead of PowerShell's. Idempotent and best-effort: any failure just
+/// leaves toasts with a generic identity, so errors are logged, not
+/// propagated. `data_dir` is the already-created `%APPDATA%/tarkov-checker`
+/// folder (sibling to config.json).
+pub fn register_aumid(app: &AppHandle, data_dir: &Path) {
+    let aumid = app.config().identifier.clone();
+    let icon_path = match write_icon(data_dir) {
+        Ok(path) => path,
+        Err(err) => {
+            eprintln!("[notify] icon write failed: {err}");
+            return;
+        }
+    };
+    if let Err(err) = write_registry(&aumid, &icon_path) {
+        eprintln!("[notify] AUMID registration failed: {err}");
+    }
+}
+
+fn write_icon(data_dir: &Path) -> std::io::Result<PathBuf> {
+    let path = data_dir.join("notification-icon.png");
+    std::fs::write(&path, ICON_BYTES)?;
+    Ok(path)
+}
+
+fn write_registry(aumid: &str, icon_path: &Path) -> std::io::Result<()> {
+    use winreg::enums::HKEY_CURRENT_USER;
+    use winreg::RegKey;
+
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+    let (key, _) = hkcu.create_subkey(format!("Software\\Classes\\AppUserModelId\\{aumid}"))?;
+    key.set_value("DisplayName", &"tarkov-checker")?;
+    key.set_value("IconUri", &icon_path.display().to_string())?;
+    Ok(())
+}
+
+/// Emits a toast attributed to our registered AUMID. Title + body arrive
+/// pre-localised from the webview.
+pub fn show_toast(app: &AppHandle, title: &str, body: &str) -> Result<(), String> {
+    let aumid = app.config().identifier.clone();
+    Toast::new(&aumid)
+        .title(title)
+        .text1(body)
+        .show()
+        .map_err(|err| err.to_string())
+}
diff --git a/apps/desktop/src-tauri/src/server/config.rs b/apps/desktop/src-tauri/src/server/config.rs
index 061c0cb..cf0e1e1 100644
--- a/apps/desktop/src-tauri/src/server/config.rs
+++ b/apps/desktop/src-tauri/src/server/config.rs
@@ -19,6 +19,10 @@ pub struct StoredConfig {
     pub game_dir: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub screenshots_dir: Option<String>,
+    /// Delete each Tarkov screenshot after the watcher parses its position
+    /// from the filename. Opt-in (default false) — see `screenshots.rs`.
+    #[serde(default)]
+    pub delete_screenshots: bool,
 }
 
 /// PUT body. Each field is optional; only the keys present are updated.
@@ -30,6 +34,8 @@ pub struct ConfigPatch {
     pub game_dir: Option<Option<String>>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub screenshots_dir: Option<Option<String>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub delete_screenshots: Option<bool>,
 }
 
 pub struct ConfigStore {
@@ -60,6 +66,11 @@ impl ConfigStore {
         }
     }
 
+    /// Current value of the "delete screenshots after parse" toggle.
+    pub async fn delete_screenshots(&self) -> bool {
+        self.state.lock().await.delete_screenshots
+    }
+
     pub async fn apply(&self, patch: ConfigPatch) -> Result<()> {
         // Validate all fields before acquiring the lock so a rejected UNC path
         // never partially mutates state (e.g. game_dir updated but
@@ -81,6 +92,9 @@ impl ConfigStore {
             if let Some(v) = screenshots_dir {
                 s.screenshots_dir = v;
             }
+            if let Some(v) = patch.delete_screenshots {
+                s.delete_screenshots = v;
+            }
         }
         self.persist().await
     }
diff --git a/apps/desktop/src-tauri/src/server/events.rs b/apps/desktop/src-tauri/src/server/events.rs
index 2080aa8..dab8ec8 100644
--- a/apps/desktop/src-tauri/src/server/events.rs
+++ b/apps/desktop/src-tauri/src/server/events.rs
@@ -18,6 +18,22 @@
 use serde::Serialize;
 use tokio::sync::broadcast;
 
+use crate::server::hotkeys::HotkeyConfig;
+
+/// Action codes the backend forwards to every client on a global-hotkey
+/// press. Mirrors the TS `hotkeyActions` list in
+/// `packages/shared/src/sse-messages.ts` (kebab-case wire values). Lock is
+/// deliberately absent — it stays a client-side overlay-only shortcut.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum HotkeyAction {
+    ZoomIn,
+    ZoomOut,
+    FloorUp,
+    FloorDown,
+    Airdrop,
+}
+
 /// Wire-shape that goes onto the SSE stream. Tagged enum: the `type`
 /// field tells the client which variant arrived. Field names match the
 /// existing `position` / `map-change` Tauri-event payloads so the
@@ -38,6 +54,25 @@ pub enum ServerEvent {
         #[serde(rename = "rawMapId")]
         raw_map_id: String,
     },
+    /// A backend-registered global hotkey was pressed. Fanned out to the
+    /// SSE stream; the Tauri side also `app.emit("command", …)` so the
+    /// overlay webview reacts. Browser/phone clients dispatch the action;
+    /// no client needs the originating combo, only the action.
+    Command { action: HotkeyAction },
+    /// The backend-owned hotkey config changed (a rebind on any client).
+    /// Broadcast over SSE so every other client's view stays in sync; the
+    /// originating client already has the effective config from its PUT/IPC
+    /// response. Carries the full effective config (camelCase keys via
+    /// `HotkeyConfig`'s own serde rename).
+    Hotkeys { config: HotkeyConfig },
+}
+
+/// Payload for the Tauri `command` webview event. The channel name already
+/// carries the discriminator, so this is the `Command` variant minus its
+/// `type` tag — mirrors how `position`/`map-change` payloads are emitted.
+#[derive(Debug, Clone, Copy, Serialize)]
+pub struct CommandPayload {
+    pub action: HotkeyAction,
 }
 
 /// Capacity for the broadcast buffer. A position event is ~64 bytes
diff --git a/apps/desktop/src-tauri/src/server/hotkeys.rs b/apps/desktop/src-tauri/src/server/hotkeys.rs
new file mode 100644
index 0000000..b06dd86
--- /dev/null
+++ b/apps/desktop/src-tauri/src/server/hotkeys.rs
@@ -0,0 +1,240 @@
+//! Backend-owned store for the global hotkey combos.
+//!
+//! Persisted in `%APPDATA%/tarkov-checker/hotkeys.json` — a sibling to
+//! `config.json` so the `/api/config` (paths) contract stays clean. Holds
+//! the five forwarded actions only; the overlay lock combo lives client-side
+//! (see CLAUDE.md "Desktop overlay" / the hotkey rework plan).
+//!
+//! Each combo is an accelerator string (`CommandOrControl+Alt+D`, …) parseable
+//! by `global_hotkey::hotkey::HotKey::from_str` — the same format the client
+//! recorder emits. `apply` validates every supplied string before mutating
+//! state so a single bad combo can't half-update the file.
+
+use std::path::PathBuf;
+use std::str::FromStr;
+
+use anyhow::{Context, Result};
+use global_hotkey::hotkey::HotKey;
+use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
+
+/// Defaults match the client's historical `tc.hotkeys.*` values so an
+/// un-customised install behaves identically and the one-time client
+/// migration is a no-op.
+const DEFAULT_ZOOM_IN: &str = "CommandOrControl+=";
+const DEFAULT_ZOOM_OUT: &str = "CommandOrControl+-";
+const DEFAULT_FLOOR_UP: &str = "CommandOrControl+Shift+=";
+const DEFAULT_FLOOR_DOWN: &str = "CommandOrControl+Shift+-";
+const DEFAULT_AIRDROP: &str = "CommandOrControl+Alt+D";
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HotkeyConfig {
+    pub zoom_in: String,
+    pub zoom_out: String,
+    pub floor_up: String,
+    pub floor_down: String,
+    pub airdrop: String,
+}
+
+impl Default for HotkeyConfig {
+    fn default() -> Self {
+        Self {
+            zoom_in: DEFAULT_ZOOM_IN.to_string(),
+            zoom_out: DEFAULT_ZOOM_OUT.to_string(),
+            floor_up: DEFAULT_FLOOR_UP.to_string(),
+            floor_down: DEFAULT_FLOOR_DOWN.to_string(),
+            airdrop: DEFAULT_AIRDROP.to_string(),
+        }
+    }
+}
+
+/// PUT body. Each field optional; only present keys are updated.
+#[derive(Debug, Clone, Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HotkeyPatch {
+    #[serde(default)]
+    pub zoom_in: Option<String>,
+    #[serde(default)]
+    pub zoom_out: Option<String>,
+    #[serde(default)]
+    pub floor_up: Option<String>,
+    #[serde(default)]
+    pub floor_down: Option<String>,
+    #[serde(default)]
+    pub airdrop: Option<String>,
+}
+
+/// Validate an accelerator string by round-tripping it through the same
+/// parser the registration layer uses. Returns the trimmed string on success.
+fn validate(combo: &str) -> Result<String, String> {
+    let t = combo.trim();
+    HotKey::from_str(t)
+        .map(|_| t.to_string())
+        .map_err(|e| format!("invalid hotkey \"{t}\": {e}"))
+}
+
+pub struct HotkeyStore {
+    file: PathBuf,
+    state: Mutex<HotkeyConfig>,
+}
+
+impl HotkeyStore {
+    pub async fn load(file: PathBuf) -> Result<Self> {
+        let state = match tokio::fs::read_to_string(&file).await {
+            Ok(text) => serde_json::from_str(&text).unwrap_or_default(),
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => HotkeyConfig::default(),
+            Err(e) => return Err(e).context(format!("read {}", file.display())),
+        };
+        Ok(Self {
+            file,
+            state: Mutex::new(state),
+        })
+    }
+
+    pub async fn get(&self) -> HotkeyConfig {
+        self.state.lock().await.clone()
+    }
+
+    /// Apply a patch: validate every supplied combo first, then merge and
+    /// persist. Returns the merged config. Rejects (without mutating) on the
+    /// first unparseable combo.
+    pub async fn apply(&self, patch: HotkeyPatch) -> Result<HotkeyConfig, String> {
+        let zoom_in = patch.zoom_in.map(|s| validate(&s)).transpose()?;
+        let zoom_out = patch.zoom_out.map(|s| validate(&s)).transpose()?;
+        let floor_up = patch.floor_up.map(|s| validate(&s)).transpose()?;
+        let floor_down = patch.floor_down.map(|s| validate(&s)).transpose()?;
+        let airdrop = patch.airdrop.map(|s| validate(&s)).transpose()?;
+
+        let merged = {
+            let mut s = self.state.lock().await;
+            if let Some(v) = zoom_in {
+                s.zoom_in = v;
+            }
+            if let Some(v) = zoom_out {
+                s.zoom_out = v;
+            }
+            if let Some(v) = floor_up {
+                s.floor_up = v;
+            }
+            if let Some(v) = floor_down {
+                s.floor_down = v;
+            }
+            if let Some(v) = airdrop {
+                s.airdrop = v;
+            }
+            s.clone()
+        };
+
+        self.persist(&merged).await.map_err(|e| e.to_string())?;
+        Ok(merged)
+    }
+
+    /// Overwrite stored state with a fully-resolved config (used after the
+    /// manager reverts a field that failed to register). Persists.
+    pub async fn set(&self, config: HotkeyConfig) -> Result<()> {
+        {
+            let mut s = self.state.lock().await;
+            *s = config.clone();
+        }
+        self.persist(&config).await
+    }
+
+    async fn persist(&self, config: &HotkeyConfig) -> Result<()> {
+        if let Some(dir) = self.file.parent() {
+            tokio::fs::create_dir_all(dir)
+                .await
+                .with_context(|| format!("mkdir {}", dir.display()))?;
+        }
+        let body = serde_json::to_string_pretty(config).context("serialize hotkeys")?;
+        tokio::fs::write(&self.file, body)
+            .await
+            .with_context(|| format!("write {}", self.file.display()))?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn tmp_file() -> PathBuf {
+        std::env::temp_dir().join(format!(
+            "tarkov-checker-hotkeys-test-{}-{}.json",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap_or_default()
+                .as_nanos(),
+        ))
+    }
+
+    #[test]
+    fn defaults_all_parse_as_hotkeys() {
+        let cfg = HotkeyConfig::default();
+        for combo in [
+            &cfg.zoom_in,
+            &cfg.zoom_out,
+            &cfg.floor_up,
+            &cfg.floor_down,
+            &cfg.airdrop,
+        ] {
+            assert!(
+                HotKey::from_str(combo).is_ok(),
+                "default combo should parse: {combo}"
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn load_missing_file_yields_defaults() {
+        let store = HotkeyStore::load(tmp_file()).await.unwrap();
+        assert_eq!(store.get().await, HotkeyConfig::default());
+    }
+
+    #[tokio::test]
+    async fn apply_patches_only_supplied_fields_and_persists() {
+        let file = tmp_file();
+        let store = HotkeyStore::load(file.clone()).await.unwrap();
+        let merged = store
+            .apply(HotkeyPatch {
+                zoom_in: Some("CommandOrControl+Alt+Z".to_string()),
+                ..Default::default()
+            })
+            .await
+            .unwrap();
+        assert_eq!(merged.zoom_in, "CommandOrControl+Alt+Z");
+        assert_eq!(merged.airdrop, HotkeyConfig::default().airdrop);
+
+        // Reload from disk — the change must have persisted.
+        let reloaded = HotkeyStore::load(file).await.unwrap();
+        assert_eq!(reloaded.get().await.zoom_in, "CommandOrControl+Alt+Z");
+    }
+
+    #[tokio::test]
+    async fn apply_rejects_unparseable_combo_without_mutating() {
+        let store = HotkeyStore::load(tmp_file()).await.unwrap();
+        let result = store
+            .apply(HotkeyPatch {
+                zoom_in: Some("totally+nonsense+key".to_string()),
+                ..Default::default()
+            })
+            .await;
+        assert!(result.is_err(), "bad combo should be rejected");
+        // State untouched.
+        assert_eq!(store.get().await, HotkeyConfig::default());
+    }
+
+    #[tokio::test]
+    async fn apply_trims_whitespace() {
+        let store = HotkeyStore::load(tmp_file()).await.unwrap();
+        let merged = store
+            .apply(HotkeyPatch {
+                airdrop: Some("  CommandOrControl+Alt+D  ".to_string()),
+                ..Default::default()
+            })
+            .await
+            .unwrap();
+        assert_eq!(merged.airdrop, "CommandOrControl+Alt+D");
+    }
+}
diff --git a/apps/desktop/src-tauri/src/server/logs.rs b/apps/desktop/src-tauri/src/server/logs.rs
index 7378670..e684b6e 100644
--- a/apps/desktop/src-tauri/src/server/logs.rs
+++ b/apps/desktop/src-tauri/src/server/logs.rs
@@ -78,6 +78,31 @@ struct ActiveLog {
     partial: String,
 }
 
+/// Chronological sort key parsed from a `log_*` folder name. Tarkov names
+/// sessions `log_<Y>.<M>.<D>_<H>-<M>-<S>_<version>` with the HOUR written
+/// WITHOUT a leading zero (`log_2026.06.07_3-16-27_...`), so a plain
+/// lexicographic sort puts a 3 AM session AFTER a 2 PM one (`'3' > '1'`) and
+/// the watcher latches onto the wrong (often stale) folder. Parsing the numeric
+/// components makes ordering follow actual time. Unparseable names get the
+/// all-zero key so a real, parseable session always wins `.last()`.
+fn session_sort_key(path: &Path) -> (u32, u32, u32, u32, u32, u32) {
+    fn parse(path: &Path) -> Option<(u32, u32, u32, u32, u32, u32)> {
+        let name = path.file_name()?.to_str()?;
+        let rest = name.strip_prefix(SESSION_FOLDER_PREFIX)?; // "2026.06.07_3-16-27_<ver>"
+        let mut parts = rest.split('_');
+        let mut date = parts.next()?.split('.');
+        let mut time = parts.next()?.split('-');
+        let year = date.next()?.parse().ok()?;
+        let month = date.next()?.parse().ok()?;
+        let day = date.next()?.parse().ok()?;
+        let hour = time.next()?.parse().ok()?;
+        let min = time.next()?.parse().ok()?;
+        let sec = time.next()?.parse().ok()?;
+        Some((year, month, day, hour, min, sec))
+    }
+    parse(path).unwrap_or((0, 0, 0, 0, 0, 0))
+}
+
 fn list_session_folders(logs_dir: &Path) -> Vec<PathBuf> {
     let mut out: Vec<PathBuf> = match fs::read_dir(logs_dir) {
         Ok(it) => it
@@ -93,7 +118,9 @@ fn list_session_folders(logs_dir: &Path) -> Vec<PathBuf> {
             .collect(),
         Err(_) => Vec::new(),
     };
-    out.sort();
+    // Chronological (NOT lexicographic — the hour has no leading zero); callers
+    // take `.last()` for the most recent session.
+    out.sort_by_key(|p| session_sort_key(p));
     out
 }
 
@@ -148,7 +175,7 @@ fn find_latest_map_id_in_file(path: &Path) -> Option<String> {
 }
 
 fn emit_map_change(
-    app: &AppHandle,
+    app: Option<&AppHandle>,
     state: &Mutex<State>,
     event_tx: &broadcast::Sender<ServerEvent>,
     raw_map_id: String,
@@ -165,22 +192,26 @@ fn emit_map_change(
     drop(guard);
 
     let t = now_ms();
-    // Tauri webview path — unchanged shape.
-    let payload = MapChangePayload {
-        t,
-        raw_map_id: raw_map_id.clone(),
-    };
-    if let Err(err) = app.emit("map-change", &payload) {
-        eprintln!("[logs-watcher] emit failed: {err}");
+    if let Some(app) = app {
+        let payload = MapChangePayload {
+            t,
+            raw_map_id: raw_map_id.clone(),
+        };
+        if let Err(err) = app.emit("map-change", &payload) {
+            eprintln!("[logs-watcher] emit failed: {err}");
+        }
     }
-    // HTTP /events path — same data, tagged enum. `send` errors only on
-    // zero subscribers (normal when /events is unopened); ignore.
+    // HTTP /events path — unconditional; no Tauri webview needed.
     let _ = event_tx.send(ServerEvent::MapChange { t, raw_map_id });
 }
 
 /// Seek + read appended bytes for the currently-tailed log file, parse line
 /// by line, emit on hit. Idempotent — safe to call on every poll tick.
-fn read_appended(app: &AppHandle, state: &Mutex<State>, event_tx: &broadcast::Sender<ServerEvent>) {
+fn read_appended(
+    app: Option<&AppHandle>,
+    state: &Mutex<State>,
+    event_tx: &broadcast::Sender<ServerEvent>,
+) {
     // Snapshot the path + offset under the lock so the actual I/O happens
     // outside it.
     let snapshot: Option<(PathBuf, u64, String)> = {
@@ -257,7 +288,7 @@ fn read_appended(app: &AppHandle, state: &Mutex<State>, event_tx: &broadcast::Se
 /// only on startup — when we discover a brand-new folder mid-session, the
 /// folder is empty and we just wait for the tail to pick up new lines.
 fn attach_to_session(
-    app: &AppHandle,
+    app: Option<&AppHandle>,
     state: &Mutex<State>,
     event_tx: &broadcast::Sender<ServerEvent>,
     folder: PathBuf,
@@ -336,7 +367,7 @@ fn check_within_session_rotation(state: &Mutex<State>) {
 /// here so we don't have to thread name-comparison logic through the event
 /// channel.
 fn check_new_session_folder(
-    app: &AppHandle,
+    app: Option<&AppHandle>,
     state: &Mutex<State>,
     event_tx: &broadcast::Sender<ServerEvent>,
     logs_dir: &Path,
@@ -349,8 +380,10 @@ fn check_new_session_folder(
         let guard = state.lock().expect("logs state poisoned");
         guard.active_folder.clone()
     };
+    // Compare by parsed timestamp, not path order — same leading-zero-hour
+    // pitfall as the folder sort above.
     let is_newer = match &current {
-        Some(c) => latest > *c,
+        Some(c) => session_sort_key(&latest) > session_sort_key(c),
         None => true,
     };
     if !is_newer {
@@ -389,7 +422,7 @@ impl Drop for LogsWatcher {
 ///     `application_NNN.log` is rotated inside the active session.
 pub fn start(
     logs_dir: PathBuf,
-    app: AppHandle,
+    app: Option<AppHandle>,
     event_tx: broadcast::Sender<ServerEvent>,
 ) -> Result<LogsWatcher> {
     let state = Arc::new(Mutex::new(State {
@@ -400,7 +433,7 @@ pub fn start(
 
     // Initial seed from latest existing session, if any.
     if let Some(latest) = list_session_folders(&logs_dir).last().cloned() {
-        attach_to_session(&app, &state, &event_tx, latest, true);
+        attach_to_session(app.as_ref(), &state, &event_tx, latest, true);
     } else {
         eprintln!(
             "[logs-watcher] no existing tarkov log sessions yet at {}",
@@ -440,7 +473,7 @@ pub fn start(
                     break;
                 }
                 check_new_session_folder(
-                    &app_for_folders,
+                    app_for_folders.as_ref(),
                     &state_for_folders,
                     &event_tx_for_folders,
                     &logs_dir_for_folders,
@@ -462,7 +495,7 @@ pub fn start(
             while !stop_for_tail.load(Ordering::SeqCst) {
                 std::thread::sleep(Duration::from_millis(300));
                 check_within_session_rotation(&state_for_tail);
-                read_appended(&app_for_tail, &state_for_tail, &event_tx_for_tail);
+                read_appended(app_for_tail.as_ref(), &state_for_tail, &event_tx_for_tail);
             }
         })
         .context("spawn logs tail watcher thread")?;
@@ -479,6 +512,40 @@ pub fn start(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::path::PathBuf;
+
+    // --- session folder ordering --------------------------------------------
+
+    #[test]
+    fn session_sort_key_orders_by_time_not_lexicographically() {
+        // EFT writes the hour without a leading zero, so a 3 AM session would
+        // sort AFTER a 2:56 PM one under a plain string sort. The parsed key
+        // must put the afternoon session later (greater).
+        let morning = PathBuf::from("log_2026.06.07_3-16-27_1.0.5.0.45464");
+        let afternoon = PathBuf::from("log_2026.06.07_14-56-33_1.0.5.0.45464");
+        assert!(
+            session_sort_key(&afternoon) > session_sort_key(&morning),
+            "14:56 must sort after 03:16"
+        );
+        // And a `.last()` over the unsorted set must pick the afternoon one.
+        let mut folders = [afternoon.clone(), morning];
+        folders.sort_by_key(|p| session_sort_key(p));
+        assert_eq!(folders.last(), Some(&afternoon));
+    }
+
+    #[test]
+    fn session_sort_key_orders_across_days() {
+        let older = PathBuf::from("log_2026.06.06_23-00-00_1.0.5.0");
+        let newer = PathBuf::from("log_2026.06.07_1-00-00_1.0.5.0");
+        assert!(session_sort_key(&newer) > session_sort_key(&older));
+    }
+
+    #[test]
+    fn session_sort_key_unparseable_sorts_first() {
+        let junk = PathBuf::from("log_not_a_timestamp");
+        let real = PathBuf::from("log_2026.06.07_3-16-27_1.0.5.0");
+        assert!(session_sort_key(&real) > session_sort_key(&junk));
+    }
 
     // --- SCENE_PRESET_RE cases -----------------------------------------------
 
diff --git a/apps/desktop/src-tauri/src/server/mod.rs b/apps/desktop/src-tauri/src/server/mod.rs
index dbe6566..ca4f56f 100644
--- a/apps/desktop/src-tauri/src/server/mod.rs
+++ b/apps/desktop/src-tauri/src/server/mod.rs
@@ -12,6 +12,7 @@
 
 pub mod config;
 pub mod events;
+pub mod hotkeys;
 pub mod logs;
 pub mod parse_log_regexes;
 pub mod parse_screenshot_regexes;
diff --git a/apps/desktop/src-tauri/src/server/paths.rs b/apps/desktop/src-tauri/src/server/paths.rs
index a60c417..d790a98 100644
--- a/apps/desktop/src-tauri/src/server/paths.rs
+++ b/apps/desktop/src-tauri/src/server/paths.rs
@@ -51,6 +51,19 @@ pub struct ResolvedPaths {
     pub screenshots_dir: ResolvedPath,
 }
 
+/// What `GET`/`PUT /api/config` (and the Tauri equivalents) return: the
+/// resolved path table plus the behaviour flags that live alongside paths in
+/// `config.json`. Flattened so the wire shape is
+/// `{ gameDir, logsDir, screenshotsDir, deleteScreenshots }` — matching
+/// `serverConfigResponseSchema` in `@shared/config-api`.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ConfigResponse {
+    #[serde(flatten)]
+    pub paths: ResolvedPaths,
+    pub delete_screenshots: bool,
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct ManualOverrides {
     pub game_dir: Option<String>,
diff --git a/apps/desktop/src-tauri/src/server/screenshots.rs b/apps/desktop/src-tauri/src/server/screenshots.rs
index f0dfe48..b0e3a64 100644
--- a/apps/desktop/src-tauri/src/server/screenshots.rs
+++ b/apps/desktop/src-tauri/src/server/screenshots.rs
@@ -11,7 +11,9 @@ use once_cell::sync::Lazy;
 use regex::Regex;
 use serde::Serialize;
 use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc;
+use std::sync::Arc;
 use std::time::Duration;
 use tauri::{AppHandle, Emitter};
 
@@ -115,8 +117,9 @@ pub struct ScreenshotWatcher {
 /// quiet for the whole window are reported.
 pub fn start(
     dir: PathBuf,
-    app: AppHandle,
+    app: Option<AppHandle>,
     event_tx: tokio::sync::broadcast::Sender<crate::server::events::ServerEvent>,
+    delete_screenshots: Arc<AtomicBool>,
 ) -> Result<ScreenshotWatcher> {
     let (tx, rx) = mpsc::channel::<notify_debouncer_full::DebounceEventResult>();
     let mut debouncer =
@@ -144,7 +147,7 @@ pub fn start(
                     Err(_) => continue,
                 };
                 for ev in events {
-                    handle_event(&app_handle, &event_tx, ev);
+                    handle_event(app_handle.as_ref(), &event_tx, ev, &delete_screenshots);
                 }
             }
         })
@@ -155,10 +158,18 @@ pub fn start(
     })
 }
 
+/// Whether a freshly-seen file should be sent to the recycle bin: only when
+/// the feature is enabled AND the filename parsed as a Tarkov screenshot.
+/// Files the user dropped in the folder that don't match are never touched.
+fn should_trash(path: &Path, enabled: bool) -> bool {
+    enabled && parse_screenshot_filename(path).is_some()
+}
+
 fn handle_event(
-    app: &AppHandle,
+    app: Option<&AppHandle>,
     event_tx: &tokio::sync::broadcast::Sender<crate::server::events::ServerEvent>,
     ev: DebouncedEvent,
+    delete_screenshots: &AtomicBool,
 ) {
     // Only fresh-on-disk files matter — chokidar in TS used the `add`
     // event which fires on initial discovery + new creates. notify's
@@ -177,23 +188,19 @@ fn handle_event(
         };
         let yaw = parsed.orientation.map(quaternion_to_yaw_degrees);
         let t = chrono_now_ms();
-        // Tauri webview path — unchanged. Uses the private PositionPayload
-        // struct so the webview's existing `listen("position", ...)` keeps
-        // working bit-for-bit.
-        let payload = PositionPayload {
-            t,
-            x: parsed.position.x,
-            y: parsed.position.y,
-            z: parsed.position.z,
-            yaw,
-        };
-        if let Err(err) = app.emit("position", &payload) {
-            eprintln!("[screenshot-watcher] emit failed: {err}");
+        if let Some(app) = app {
+            let payload = PositionPayload {
+                t,
+                x: parsed.position.x,
+                y: parsed.position.y,
+                z: parsed.position.z,
+                yaw,
+            };
+            if let Err(err) = app.emit("position", &payload) {
+                eprintln!("[screenshot-watcher] emit failed: {err}");
+            }
         }
-        // HTTP /events path — same data, ServerEvent wire-shape (tagged
-        // enum). `send` errors only when there are zero subscribers; that
-        // is the normal case when nobody has opened /events, so we ignore
-        // it silently.
+        // HTTP /events path — unconditional; no Tauri webview needed.
         let _ = event_tx.send(crate::server::events::ServerEvent::Position {
             t,
             x: parsed.position.x,
@@ -201,6 +208,19 @@ fn handle_event(
             z: parsed.position.z,
             yaw,
         });
+
+        // Opt-in cleanup: the position is already extracted from the filename
+        // and broadcast, so the image is no longer needed. Send it to the OS
+        // recycle bin (recoverable). Best-effort — a failure (file locked by
+        // the screenshot tool, permissions) is logged and ignored.
+        if should_trash(path, delete_screenshots.load(Ordering::Relaxed)) {
+            if let Err(err) = trash::delete(path) {
+                eprintln!(
+                    "[screenshot-watcher] recycle failed for {}: {err}",
+                    path.display()
+                );
+            }
+        }
     }
 }
 
@@ -217,6 +237,30 @@ mod tests {
     use super::*;
     use std::path::Path;
 
+    // -----------------------------------------------------------------------
+    // should_trash — only parsed Tarkov screenshots are ever deleted
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn should_trash_parsed_screenshot_when_enabled() {
+        let path = Path::new("2026-05-30 12-34-56_-100.5, 50.0, 200.3_0,0,0.7,0.7_.png");
+        assert!(should_trash(path, true));
+    }
+
+    #[test]
+    fn should_not_trash_when_disabled() {
+        let path = Path::new("2026-05-30 12-34-56_-100.5, 50.0, 200.3_0,0,0.7,0.7_.png");
+        assert!(!should_trash(path, false));
+    }
+
+    #[test]
+    fn should_not_trash_unparseable_file_even_when_enabled() {
+        // A user's own file that isn't a Tarkov position screenshot must
+        // survive even with the feature on.
+        assert!(!should_trash(Path::new("my vacation.png"), true));
+        assert!(!should_trash(Path::new("notes.txt"), true));
+    }
+
     // -----------------------------------------------------------------------
     // parse_screenshot_filename
     // -----------------------------------------------------------------------
diff --git a/apps/desktop/src-tauri/src/updater.rs b/apps/desktop/src-tauri/src/updater.rs
new file mode 100644
index 0000000..2676693
--- /dev/null
+++ b/apps/desktop/src-tauri/src/updater.rs
@@ -0,0 +1,263 @@
+//! Portable self-update via GitHub Releases.
+//!
+//! There is no installer: a running exe on Windows can't be deleted or
+//! overwritten, but it CAN be renamed. Install therefore = download the new
+//! exe next to the current one, rename current -> `.old.exe`, rename the
+//! download into the current name, spawn it, exit. The fresh instance removes
+//! the leftover `.old.exe` on startup (`cleanup_old`).
+
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+
+use anyhow::{anyhow, Context};
+use serde::{Deserialize, Serialize};
+
+/// Repo the overlay updates from.
+const REPO: &str = "Mosmain/tarkov-checker";
+/// Release asset to download — CI uploads exactly this name.
+const ASSET_NAME: &str = "tarkov-checker-desktop.exe";
+
+pub fn current_version() -> &'static str {
+    env!("CARGO_PKG_VERSION")
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateInfo {
+    pub current: String,
+    pub latest: String,
+    pub release_url: String,
+    /// Kept internal on purpose: `install_update` re-resolves the URL itself
+    /// so the webview can never point the updater at an arbitrary host.
+    #[serde(skip)]
+    pub download_url: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct Release {
+    tag_name: String,
+    html_url: String,
+    #[serde(default)]
+    assets: Vec<Asset>,
+}
+
+#[derive(Debug, Deserialize)]
+struct Asset {
+    name: String,
+    browser_download_url: String,
+}
+
+/// `"v1.2.3"` / `"1.2.3-rc1"` -> `[1, 2, 3]`. `None` for anything else.
+fn parse_version(s: &str) -> Option<[u64; 3]> {
+    let s = s.trim().trim_start_matches(['v', 'V']);
+    let mut parts = s.split('.');
+    let major = parts.next()?.parse().ok()?;
+    let minor = parts.next()?.parse().ok()?;
+    // tolerate a suffix on the patch ("3-rc1" -> 3)
+    let patch = parts
+        .next()?
+        .split(|c: char| !c.is_ascii_digit())
+        .next()?
+        .parse()
+        .ok()?;
+    if parts.next().is_some() {
+        return None;
+    }
+    Some([major, minor, patch])
+}
+
+/// Strict ">" — equal, older, or unparseable versions are not "newer", so a
+/// malformed tag can never trigger an install loop.
+pub fn is_newer(remote: &str, current: &str) -> bool {
+    match (parse_version(remote), parse_version(current)) {
+        (Some(r), Some(c)) => r > c,
+        _ => false,
+    }
+}
+
+fn client() -> reqwest::Result<reqwest::Client> {
+    reqwest::Client::builder()
+        // api.github.com rejects requests without a User-Agent.
+        .user_agent(concat!("tarkov-checker/", env!("CARGO_PKG_VERSION")))
+        .timeout(Duration::from_secs(60))
+        .build()
+}
+
+/// Latest published release, or `None` when up to date / no releases yet.
+pub async fn check() -> anyhow::Result<Option<UpdateInfo>> {
+    let resp = client()?
+        .get(format!(
+            "https://api.github.com/repos/{REPO}/releases/latest"
+        ))
+        .header("Accept", "application/vnd.github+json")
+        .send()
+        .await
+        .context("releases/latest request")?;
+    // 404 = the repo has no published releases yet.
+    if resp.status() == reqwest::StatusCode::NOT_FOUND {
+        return Ok(None);
+    }
+    let release: Release = resp
+        .error_for_status()
+        .context("releases/latest status")?
+        .json()
+        .await
+        .context("releases/latest body")?;
+
+    if !is_newer(&release.tag_name, current_version()) {
+        return Ok(None);
+    }
+    let asset = release
+        .assets
+        .iter()
+        .find(|a| a.name == ASSET_NAME)
+        .ok_or_else(|| anyhow!("release {} has no {ASSET_NAME} asset", release.tag_name))?;
+    Ok(Some(UpdateInfo {
+        current: current_version().to_string(),
+        latest: release.tag_name.trim_start_matches(['v', 'V']).to_string(),
+        release_url: release.html_url,
+        download_url: asset.browser_download_url.clone(),
+    }))
+}
+
+/// Downloads the new exe and swaps it into place. Returns the path of the
+/// (now replaced) current exe so the caller can respawn it.
+pub async fn download_and_swap(download_url: &str) -> anyhow::Result<PathBuf> {
+    let exe = std::env::current_exe().context("current_exe")?;
+    let bytes = client()?
+        .get(download_url)
+        .send()
+        .await
+        .context("asset download")?
+        .error_for_status()
+        .context("asset download status")?
+        .bytes()
+        .await
+        .context("asset download body")?;
+    // Sanity gate: a PE binary of plausible size, not an HTML error page.
+    if bytes.len() < 1024 * 1024 || !bytes.starts_with(b"MZ") {
+        return Err(anyhow!(
+            "downloaded file does not look like the overlay exe ({} bytes)",
+            bytes.len()
+        ));
+    }
+    let staged = staged_path(&exe);
+    tokio::fs::write(&staged, &bytes)
+        .await
+        .with_context(|| format!("write {}", staged.display()))?;
+    swap(&exe, &staged).with_context(|| format!("swap into {}", exe.display()))?;
+    Ok(exe)
+}
+
+/// The rename dance. On the second rename failing, rolls the first one back
+/// so the app is left runnable.
+fn swap(current: &Path, staged: &Path) -> std::io::Result<()> {
+    let old = old_path(current);
+    let _ = std::fs::remove_file(&old);
+    std::fs::rename(current, &old)?;
+    if let Err(e) = std::fs::rename(staged, current) {
+        let _ = std::fs::rename(&old, current);
+        return Err(e);
+    }
+    Ok(())
+}
+
+fn staged_path(current: &Path) -> PathBuf {
+    current.with_extension("new.exe")
+}
+
+fn old_path(current: &Path) -> PathBuf {
+    current.with_extension("old.exe")
+}
+
+/// Remove the `.old.exe` left by a previous update. Runs on a background
+/// thread with retries — the previous instance may still be exiting (it can't
+/// be deleted until its process is gone).
+pub fn cleanup_old() {
+    std::thread::spawn(|| {
+        let Ok(exe) = std::env::current_exe() else {
+            return;
+        };
+        let old = old_path(&exe);
+        for _ in 0..20 {
+            if !old.exists() || std::fs::remove_file(&old).is_ok() {
+                return;
+            }
+            std::thread::sleep(Duration::from_millis(250));
+        }
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // --- version comparison ------------------------------------------------
+
+    #[test]
+    fn is_newer_basic() {
+        assert!(is_newer("0.2.0", "0.1.0"));
+        assert!(is_newer("1.0.0", "0.9.9"));
+        assert!(!is_newer("0.1.0", "0.1.0"));
+        assert!(!is_newer("0.1.0", "0.2.0"));
+    }
+
+    #[test]
+    fn is_newer_strips_tag_prefix() {
+        assert!(is_newer("v0.2.0", "0.1.0"));
+        assert!(is_newer("V0.2.0", "v0.1.0"));
+    }
+
+    #[test]
+    fn is_newer_tolerates_patch_suffix() {
+        assert!(is_newer("0.2.0-rc1", "0.1.0"));
+    }
+
+    #[test]
+    fn is_newer_rejects_garbage() {
+        assert!(!is_newer("latest", "0.1.0"));
+        assert!(!is_newer("0.2", "0.1.0"));
+        assert!(!is_newer("0.2.0.1", "0.1.0"));
+        assert!(!is_newer("0.2.0", "not-a-version"));
+    }
+
+    // --- rename dance ------------------------------------------------------
+
+    fn temp_file(name: &str, contents: &[u8]) -> PathBuf {
+        let p = std::env::temp_dir().join(format!("tc-updater-test-{}-{name}", std::process::id()));
+        std::fs::write(&p, contents).unwrap();
+        p
+    }
+
+    #[test]
+    fn swap_replaces_current_and_keeps_old() {
+        let current = temp_file("current.exe", b"OLD");
+        let staged = temp_file("current.new.exe", b"NEW");
+        // temp_file names don't follow with_extension semantics — rename
+        // staged to the path swap() derives.
+        let staged_real = staged_path(&current);
+        std::fs::rename(&staged, &staged_real).unwrap();
+
+        swap(&current, &staged_real).unwrap();
+
+        assert_eq!(std::fs::read(&current).unwrap(), b"NEW");
+        assert_eq!(std::fs::read(old_path(&current)).unwrap(), b"OLD");
+        assert!(!staged_real.exists());
+
+        let _ = std::fs::remove_file(&current);
+        let _ = std::fs::remove_file(old_path(&current));
+    }
+
+    #[test]
+    fn swap_rolls_back_when_staged_missing() {
+        let current = temp_file("rollback.exe", b"OLD");
+        let staged = staged_path(&current); // never created
+
+        assert!(swap(&current, &staged).is_err());
+        // first rename rolled back — the app is still launchable
+        assert_eq!(std::fs::read(&current).unwrap(), b"OLD");
+        assert!(!old_path(&current).exists());
+
+        let _ = std::fs::remove_file(&current);
+    }
+}
diff --git a/apps/desktop/src-tauri/src/watcher.rs b/apps/desktop/src-tauri/src/watcher.rs
index 59dbdd4..ecf38d0 100644
--- a/apps/desktop/src-tauri/src/watcher.rs
+++ b/apps/desktop/src-tauri/src/watcher.rs
@@ -2,7 +2,8 @@
 //! we can swap them atomically when resolved paths change.
 
 use std::path::PathBuf;
-use std::sync::Mutex;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
 
 use tauri::AppHandle;
 use tokio::sync::broadcast;
@@ -37,15 +38,30 @@ pub struct WatcherSlot {
     screenshots: Mutex<Option<ScreenshotWatcher>>,
     logs: Mutex<Option<LogsWatcher>>,
     event_tx: broadcast::Sender<ServerEvent>,
+    /// "Delete screenshot after parse" toggle. Shared (Arc) so a running
+    /// screenshot watcher thread reads the live value — flipping it via
+    /// `set_delete_screenshots` takes effect without restarting the watcher.
+    delete_screenshots: Arc<AtomicBool>,
 }
 
 impl Default for WatcherSlot {
     fn default() -> Self {
+        Self::with_sender(events::channel())
+    }
+}
+
+impl WatcherSlot {
+    /// Build a slot around an existing broadcast sender. Used by `run()` /
+    /// `run_headless()`, which create the channel up front so the hotkey
+    /// press handler can push `Command` events into the same stream the
+    /// watchers feed.
+    pub fn with_sender(event_tx: broadcast::Sender<ServerEvent>) -> Self {
         Self {
             apply_lock: AsyncMutex::new(()),
             screenshots: Mutex::new(None),
             logs: Mutex::new(None),
-            event_tx: events::channel(),
+            event_tx,
+            delete_screenshots: Arc::new(AtomicBool::new(false)),
         }
     }
 }
@@ -67,6 +83,12 @@ impl WatcherSlot {
     pub fn event_sender(&self) -> broadcast::Sender<ServerEvent> {
         self.event_tx.clone()
     }
+
+    /// Update the shared delete-screenshots flag. A running watcher reads it
+    /// live, so no restart is needed when only this toggle changes.
+    pub fn set_delete_screenshots(&self, enabled: bool) {
+        self.delete_screenshots.store(enabled, Ordering::Relaxed);
+    }
 }
 
 /// Apply the resolved paths: start each watcher if its path is usable,
@@ -76,7 +98,7 @@ impl WatcherSlot {
 /// Acquires `apply_lock` for the full duration so that concurrent calls
 /// (e.g. two rapid `update_config` IPC commands) are serialised rather
 /// than interleaved — preventing duplicate watcher instances.
-pub async fn apply_resolved(app: &AppHandle, slot: &WatcherSlot, resolved: &ResolvedPaths) {
+pub async fn apply_resolved(app: Option<&AppHandle>, slot: &WatcherSlot, resolved: &ResolvedPaths) {
     let _guard = slot.apply_lock.lock().await;
 
     let screenshots_dir = match (
@@ -87,7 +109,12 @@ pub async fn apply_resolved(app: &AppHandle, slot: &WatcherSlot, resolved: &Reso
         _ => None,
     };
     match screenshots_dir {
-        Some(dir) => match screenshots::start(dir, app.clone(), slot.event_tx.clone()) {
+        Some(dir) => match screenshots::start(
+            dir,
+            app.cloned(),
+            slot.event_tx.clone(),
+            slot.delete_screenshots.clone(),
+        ) {
             Ok(w) => slot.replace_screenshots(Some(w)),
             Err(err) => {
                 eprintln!("[watcher] screenshots start failed: {err:#}");
@@ -102,7 +129,7 @@ pub async fn apply_resolved(app: &AppHandle, slot: &WatcherSlot, resolved: &Reso
         _ => None,
     };
     match logs_dir {
-        Some(dir) => match logs::start(dir, app.clone(), slot.event_tx.clone()) {
+        Some(dir) => match logs::start(dir, app.cloned(), slot.event_tx.clone()) {
             Ok(w) => slot.replace_logs(Some(w)),
             Err(err) => {
                 eprintln!("[watcher] logs start failed: {err:#}");
diff --git a/apps/desktop/src-tauri/tauri.conf.json b/apps/desktop/src-tauri/tauri.conf.json
index 70ee789..fd9588c 100644
--- a/apps/desktop/src-tauri/tauri.conf.json
+++ b/apps/desktop/src-tauri/tauri.conf.json
@@ -1,7 +1,6 @@
 {
   "$schema": "https://schema.tauri.app/config/2.0.0",
   "productName": "tarkov-checker",
-  "version": "0.0.0",
   "identifier": "dev.tarkov-checker.desktop",
   "build": {
     "frontendDist": "../../client/dist",
diff --git a/package.json b/package.json
index 2be7345..eae9341 100644
--- a/package.json
+++ b/package.json
@@ -9,13 +9,17 @@
   },
   "scripts": {
     "dev": "turbo run dev",
+    "dev:frontend": "pnpm --filter @tarkov-checker/client dev",
+    "dev:backend": "pnpm --filter @tarkov-checker/desktop backend:dev",
+    "dev:tauri": "pnpm --filter @tarkov-checker/desktop tauri:dev",
     "build": "turbo run build",
     "lint": "turbo run lint",
+    "lint:fix": "turbo run lint:fix",
     "typecheck": "turbo run typecheck",
     "test": "turbo run test",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "overlay:build": "pnpm --filter @tarkov-checker/shared build && pnpm --filter @tarkov-checker/client build && pnpm --filter @tarkov-checker/desktop tauri build",
+    "format": "prettier --check .",
+    "format:fix": "prettier --write .",
+    "build:overlay": "pnpm --filter @tarkov-checker/shared build && pnpm --filter @tarkov-checker/client build && pnpm --filter @tarkov-checker/desktop tauri build",
     "shared:gen-rust-regex": "node packages/shared/scripts/gen-rust-regex.mjs",
     "shared:gen-rust-regex:check": "node packages/shared/scripts/gen-rust-regex.mjs && git diff --exit-code apps/desktop/src-tauri/src/server/parse_log_regexes.rs apps/desktop/src-tauri/src/server/parse_screenshot_regexes.rs"
   },
diff --git a/packages/shared/package.json b/packages/shared/package.json
index 04f39f5..568db79 100644
--- a/packages/shared/package.json
+++ b/packages/shared/package.json
@@ -10,9 +10,9 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./ws-messages": {
-      "types": "./dist/ws-messages.d.ts",
-      "import": "./dist/ws-messages.js"
+    "./sse-messages": {
+      "types": "./dist/sse-messages.d.ts",
+      "import": "./dist/sse-messages.js"
     },
     "./maps": {
       "types": "./dist/maps.d.ts",
@@ -27,6 +27,7 @@
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "lint": "eslint src --max-warnings=0",
+    "lint:fix": "eslint src --max-warnings=0 --fix",
     "gen-rust-regex": "node scripts/gen-rust-regex.mjs"
   },
   "dependencies": {
diff --git a/packages/shared/src/config-api.ts b/packages/shared/src/config-api.ts
index e6bce0b..b0bc4cd 100644
--- a/packages/shared/src/config-api.ts
+++ b/packages/shared/src/config-api.ts
@@ -12,6 +12,12 @@ export const serverConfigResponseSchema = z.object({
   gameDir: resolvedPathSchema,
   logsDir: resolvedPathSchema,
   screenshotsDir: resolvedPathSchema,
+  /** When true, the helper deletes each Tarkov screenshot after parsing its
+   * position out of the filename (the image itself is never used). Opt-in;
+   * keeps the screenshots folder from filling up over long sessions.
+   * `.default(false)` so a response from an older helper (which omits the
+   * field) still parses instead of hard-failing on version skew. */
+  deleteScreenshots: z.boolean().default(false),
 });
 
 /**
@@ -22,6 +28,7 @@ export const serverConfigResponseSchema = z.object({
 export const serverConfigUpdateSchema = z.object({
   gameDir: z.string().nullable().optional(),
   screenshotsDir: z.string().nullable().optional(),
+  deleteScreenshots: z.boolean().optional(),
 });
 
 export type PathSource = z.infer<typeof pathSourceSchema>;
diff --git a/packages/shared/src/hotkeys-api.ts b/packages/shared/src/hotkeys-api.ts
new file mode 100644
index 0000000..052e620
--- /dev/null
+++ b/packages/shared/src/hotkeys-api.ts
@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { hotkeyActions, type HotkeyActionCode } from './sse-messages.js';
+
+/**
+ * Accelerator string in Tauri/Electron format: one or more modifiers + a
+ * non-empty main key, e.g. `CommandOrControl+Alt+L`. Bare keys (incl. the
+ * F-row) are rejected — Tarkov claims them via DirectInput and the OS
+ * RegisterHotKey loses the race. Shared between the client recorder/store
+ * and the backend `/api/hotkeys` validation so both ports agree.
+ */
+export const acceleratorSchema = z
+  .string()
+  .regex(/^((CommandOrControl|Control|Ctrl|Alt|Shift|Meta|Super)\+)+[^+\s]+$/);
+
+/** The five backend-forwarded actions (re-exported from the wire enum so
+ * there's one list to maintain). Lock is deliberately NOT here — it stays a
+ * client-side overlay-only shortcut. */
+export const hotkeyActionSchema = z.enum(hotkeyActions);
+
+/** Full hotkey config the backend owns + persists in `hotkeys.json`. One
+ * accelerator per action, camelCase keys matching the Rust `HotkeyConfig`. */
+export const hotkeyConfigSchema = z.object({
+  zoomIn: acceleratorSchema,
+  zoomOut: acceleratorSchema,
+  floorUp: acceleratorSchema,
+  floorDown: acceleratorSchema,
+  airdrop: acceleratorSchema,
+});
+
+/** PUT body — every field optional, only present keys are updated. */
+export const hotkeyPatchSchema = hotkeyConfigSchema.partial();
+
+export type HotkeyConfig = z.infer<typeof hotkeyConfigSchema>;
+export type HotkeyPatch = z.infer<typeof hotkeyPatchSchema>;
+
+/** Field name in `HotkeyConfig` ↔ wire action code. Used by the client to
+ * map a settings field to the `command` action and back. */
+export const HOTKEY_FIELD_TO_ACTION: Readonly<Record<keyof HotkeyConfig, HotkeyActionCode>> = {
+  zoomIn: 'zoom-in',
+  zoomOut: 'zoom-out',
+  floorUp: 'floor-up',
+  floorDown: 'floor-down',
+  airdrop: 'airdrop',
+};
diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.ts
index e73b172..8c76fde 100644
--- a/packages/shared/src/index.ts
+++ b/packages/shared/src/index.ts
@@ -1,6 +1,7 @@
-export * from './ws-messages.js';
+export * from './sse-messages.js';
 export * from './maps.js';
 export * from './parse-screenshot.js';
 export * from './parse-log.js';
 export * from './triangulate.js';
 export * from './config-api.js';
+export * from './hotkeys-api.js';
diff --git a/packages/shared/src/sse-messages.ts b/packages/shared/src/sse-messages.ts
new file mode 100644
index 0000000..604ca53
--- /dev/null
+++ b/packages/shared/src/sse-messages.ts
@@ -0,0 +1,66 @@
+import { z } from 'zod';
+
+export const positionMessage = z.object({
+  type: z.literal('position'),
+  t: z.number().int().nonnegative(),
+  x: z.number(),
+  y: z.number(),
+  z: z.number(),
+  /** In-game yaw in degrees (clockwise from +Z), null when the screenshot
+   * filename didn't carry an orientation quaternion. */
+  yaw: z.number().nullable().optional(),
+});
+
+export const mapChangeMessage = z.object({
+  type: z.literal('map-change'),
+  t: z.number().int().nonnegative(),
+  /** Raw mapId as logged by the game (e.g. "bigmap", "factory4_night",
+   * "sandbox_high"). The client resolves aliases through
+   * `canonicalMapCode()` from `@shared/maps`. */
+  rawMapId: z.string(),
+});
+
+/** Action codes the backend forwards to every client on a global-hotkey
+ * press. Single source of truth for the wire enum; mirrored by the Rust
+ * `HotkeyAction` (kebab-case) and consumed by `@shared/hotkeys-api`. */
+export const hotkeyActions = ['zoom-in', 'zoom-out', 'floor-up', 'floor-down', 'airdrop'] as const;
+
+/** Backend-owned global hotkey fired. The OS-level shortcut lives in the
+ * helper process, so this reaches the overlay webview (Tauri `command`
+ * event) AND every browser/phone client (SSE `/events`) identically. */
+export const commandMessage = z.object({
+  type: z.literal('command'),
+  action: z.enum(hotkeyActions),
+});
+
+/** The backend-owned hotkey config changed (a rebind on any client). Broadcast
+ * so every other client's view stays in sync — e.g. the phone's read-only list.
+ * The originating client already has the effective config from its PUT response.
+ * The `config` shape mirrors `HotkeyConfig` in `@shared/hotkeys-api`; it's
+ * inlined here (not imported) to avoid a circular import — `hotkeys-api` imports
+ * `hotkeyActions` from this module. */
+export const hotkeysMessage = z.object({
+  type: z.literal('hotkeys'),
+  config: z.object({
+    zoomIn: z.string(),
+    zoomOut: z.string(),
+    floorUp: z.string(),
+    floorDown: z.string(),
+    airdrop: z.string(),
+  }),
+});
+
+export const serverMessage = z.discriminatedUnion('type', [
+  positionMessage,
+  mapChangeMessage,
+  commandMessage,
+  hotkeysMessage,
+]);
+
+export type PositionMessage = z.infer<typeof positionMessage>;
+export type MapChangeMessage = z.infer<typeof mapChangeMessage>;
+export type CommandMessage = z.infer<typeof commandMessage>;
+export type HotkeysMessage = z.infer<typeof hotkeysMessage>;
+export type HotkeyActionCode = (typeof hotkeyActions)[number];
+export type ServerMessage = z.infer<typeof serverMessage>;
+export type ServerMessageType = ServerMessage['type'];
diff --git a/packages/shared/src/tarkov-time.ts b/packages/shared/src/tarkov-time.ts
new file mode 100644
index 0000000..3a1eaf5
--- /dev/null
+++ b/packages/shared/src/tarkov-time.ts
@@ -0,0 +1,44 @@
+/**
+ * Escape from Tarkov in-game clock.
+ *
+ * Tarkov time runs at 7× real time, anchored to Moscow (UTC+3) — a full
+ * 24h day passes in ~3h26m of real time. Two clocks are shown in-raid,
+ * offset by 12 in-game hours (the canonical tarkov.dev formula). This is
+ * pure arithmetic on a millisecond timestamp so it can be unit-tested
+ * without faking `Date`.
+ */
+const TARKOV_RATIO = 7;
+const MOSCOW_OFFSET_MS = 3 * 60 * 60 * 1000; // UTC+3 (Norvinsk / Russia)
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+const HALF_DAY_MS = 12 * 60 * 60 * 1000;
+
+function timeOfDayMs(nowMs: number, rightSide: boolean): number {
+  const offset = MOSCOW_OFFSET_MS + (rightSide ? HALF_DAY_MS : 0);
+  return (((offset + nowMs * TARKOV_RATIO) % ONE_DAY_MS) + ONE_DAY_MS) % ONE_DAY_MS;
+}
+
+function formatHHMM(ms: number): string {
+  const totalMinutes = Math.floor(ms / 60000);
+  const hours = Math.floor(totalMinutes / 60) % 24;
+  const minutes = totalMinutes % 60;
+  return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}`;
+}
+
+export interface TarkovClock {
+  /** Left clock (e.g. 11:34). */
+  readonly left: string;
+  /** Right clock, +12h from the left (e.g. 23:34). */
+  readonly right: string;
+  /** Seconds (e.g. 07) — identical for both clocks, which differ by exactly 12h. */
+  readonly seconds: string;
+}
+
+/** Both in-game clocks for the given real-time millisecond timestamp. */
+export function tarkovTime(nowMs: number): TarkovClock {
+  const leftMs = timeOfDayMs(nowMs, false);
+  return {
+    left: formatHHMM(leftMs),
+    right: formatHHMM(timeOfDayMs(nowMs, true)),
+    seconds: String(Math.floor((leftMs % 60000) / 1000)).padStart(2, '0'),
+  };
+}
diff --git a/packages/shared/src/ws-messages.ts b/packages/shared/src/ws-messages.ts
deleted file mode 100644
index 44e0744..0000000
--- a/packages/shared/src/ws-messages.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { z } from 'zod';
-
-export const positionMessage = z.object({
-  type: z.literal('position'),
-  t: z.number().int().nonnegative(),
-  x: z.number(),
-  y: z.number(),
-  z: z.number(),
-  /** In-game yaw in degrees (clockwise from +Z), null when the screenshot
-   * filename didn't carry an orientation quaternion. */
-  yaw: z.number().nullable().optional(),
-});
-
-export const mapChangeMessage = z.object({
-  type: z.literal('map-change'),
-  t: z.number().int().nonnegative(),
-  /** Raw mapId as logged by the game (e.g. "bigmap", "factory4_night",
-   * "sandbox_high"). The client resolves aliases through
-   * `canonicalMapCode()` from `@shared/maps`. */
-  rawMapId: z.string(),
-});
-
-export const serverMessage = z.discriminatedUnion('type', [positionMessage, mapChangeMessage]);
-
-export type PositionMessage = z.infer<typeof positionMessage>;
-export type MapChangeMessage = z.infer<typeof mapChangeMessage>;
-export type ServerMessage = z.infer<typeof serverMessage>;
-export type ServerMessageType = ServerMessage['type'];
diff --git a/turbo.json b/turbo.json
index d570098..26c11c3 100644
--- a/turbo.json
+++ b/turbo.json
@@ -10,6 +10,9 @@
       "dependsOn": ["^build"]
     },
     "lint": {},
+    "lint:fix": {
+      "cache": false
+    },
     "test": {
       "dependsOn": ["^build"]
     },