Restructure step 2: Status as one computed level, the Notifier's real policy, system notifications

- Status: computed from connection, presence, hold, relay, player facts;
  no setters (health writes and HealthStatus gone); pill, strip and
  source line read it; transitions go to the Notifier.
- Notifier: noticeFor(event, context) with self presence, alone, window
  activity, playing and prefs; toasts for joins/leaves/returns/swaps/
  Up next adds (with picture)/problems/chat, the rest logged; while
  sitting out only chat, nudges, starting, Up next (+ joins if chosen);
  alone no social notices; replayed lines logged; owns its toast timer.
- System notifications (flutter_local_notifications: D-Bus on Linux,
  WinRT on Windows) when the window isn't focused; a click focuses it.
- Toasts sit above the control bar and move with it.
- Versions: each member's in the members card and avatar tooltip,
  the server's in the card header; the strip no longer shows it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.gitea/workflows/ci.yml

@@ -1,6 +1,9 @@
 name: ci
 on:
+  # Branches only: a release tag points at a commit CI already checked on
+  # main, and release.yml builds it.
   push:
+    branches: ['**']
   pull_request:
 
 jobs:
@@ -32,14 +35,17 @@ jobs:
       - run: dart test
         working-directory: packages/server
       # Compiling the dedicated server proves it stays Flutter-free.
-      - run: mkdir -p build && dart compile exe bin/server.dart -o build/watch-together-server
+      - run: mkdir -p build && dart compile exe bin/server.dart -o build/starsync-server
         working-directory: packages/server
-      - run: build/watch-together-server --help
+      - run: build/starsync-server --help
         working-directory: packages/server
 
   # The updater's Windows apply path (running exe parked as .old) only
   # means something on real NTFS. Runner notes: see release.yml.
   updater-windows:
+    # Not for a "Release v…" commit: release.yml builds it on the same
+    # (only) Windows runner, which this job would hold up.
+    if: ${{ !startsWith(github.event.head_commit.message, 'Release v') }}
     runs-on: windows-latest
     steps:
       - name: Checkout
@@ -55,5 +61,13 @@ jobs:
         run: powershell -NoProfile -ExecutionPolicy Bypass -File tool/setup_flutter_windows.ps1
       - name: Updater tests
         shell: powershell
-        working-directory: apps/desktop
-        run: flutter test test/updater_test.dart
+        working-directory: packages/core
+        run: |
+          dart pub get
+          if ($LASTEXITCODE) { exit 1 }
+          dart test test/updater_test.dart
+      # The release build, without publishing: a broken Windows build shows
+      # here, not only on a tag.
+      - name: Windows build
+        shell: powershell
+        run: powershell -NoProfile -ExecutionPolicy Bypass -File tool/package_windows.ps1

.gitea/workflows/release.yml

@@ -38,7 +38,7 @@ jobs:
           RELEASE_TOKEN: ${{ secrets.RELEASE_TOKEN }}
         run: |
           VER="${GITHUB_REF_NAME#v}"
-          dart tool/release_publish.dart "$GITHUB_REF_NAME" "dist/watch-together-$VER-linux-x64.tar.gz"
+          dart tool/release_publish.dart "$GITHUB_REF_NAME" "dist/starsync-$VER-linux-x64.tar.gz"
 
   windows:
     # yuuka-windows: host-mode runner (no containers), runs as SYSTEM, has
@@ -73,5 +73,5 @@ jobs:
           RELEASE_TOKEN: ${{ secrets.RELEASE_TOKEN }}
         run: |
           $Ver = $env:GITHUB_REF_NAME.TrimStart('v')
-          dart tool/release_publish.dart $env:GITHUB_REF_NAME "dist/watch-together-$Ver-windows-x64.zip"
+          dart tool/release_publish.dart $env:GITHUB_REF_NAME "dist/starsync-$Ver-windows-x64.zip"
           if ($LASTEXITCODE) { exit 1 }

.gitignore

@@ -17,6 +17,7 @@ coverage/
 # Build artifacts that should never be committed
 *.tar.gz
 *.zip
+/dist/
 app.*.symbols
 app.*.map.json
 

README.md

@@ -1,4 +1,8 @@
-# watch-together
+<p align="center">
+  <img src="apps/desktop/assets/icon/icon_256.png" width="128" height="128" alt="Starsync icon">
+</p>
+
+<h1 align="center">Starsync</h1>
 
 Watch a video with friends, in sync, with the quality of a real mpv player.
 Pick from your Jellyfin library, paste any direct video link, or pick a file on your own disk;
@@ -7,9 +11,9 @@ everyone's play, pause and seek stay together.
 Why not Jellyfin SyncPlay: it runs in the browser and its sync is poor.
 This is a desktop app that drives mpv.
 
-Name: `watch-together` is a placeholder and the final name is undecided
-(`sync-relay` is the working name). It appears in file names and the
-update manifest until that is settled.
+Up to 1.2.x the app was called `watch_together` (its files
+`watch-together-*`); the repository and the update manifest keep their old
+addresses for now.
 
 - Desktop only (Linux and Windows), always mpv. No web clients.
 - No transcoding. Everyone plays the original file.
@@ -21,61 +25,146 @@ How it fits together: [docs/HOW-IT-WORKS.md](docs/HOW-IT-WORKS.md).
 
 From the Releases page of this repo:
 
-- Linux: `watch-together-<version>-linux-x64.tar.gz`. Extract, run
-  `watch_together`. Needs mpv's library installed (`mpv` or `libmpv2`).
-- Windows: `watch-together-<version>-windows-x64.zip`. Extract, run
-  `watch_together.exe`. mpv is bundled. New and not yet tried on a real
+- Linux: `starsync-<version>-linux-x64.tar.gz`. Extract, run
+  `starsync`. On start it adds itself to your app launcher (and its
+  icon), so the window shows its own icon on Wayland. Needs mpv's library installed (`mpv` or `libmpv2`).
+- Windows: `starsync-<version>-windows-x64.zip`. Extract, run
+  `starsync.exe`. mpv is bundled. New and not yet tried on a real
   Windows desktop; reports welcome.
 
-Update from the app: when a newer version exists, an update indicator
-appears in the strip at the top of the window and opens the update card. "Update and restart" downloads,
-verifies, applies in place and restarts; the install folder must be writable
-by you. Settings has Check now and an auto-check toggle. From a terminal:
-`watch_together --upgrade`, or the shipped `update.sh` / `update.bat`. A
+The folder also holds `watch_together(.exe)` and
+`watch-together-server(.exe)`, the names up to 1.2.x: they start the new
+programs, so an update from 1.2.x restarts fine and old shortcuts and
+service files keep working.
+
+Your data (settings, sign-ins, folders, logs, yt-dlp and its cookies) lives
+in `~/.local/share/dev.foxyz.starsync` on Linux and
+`%APPDATA%\foxyz\Starsync` on Windows. The first start after 1.2.x copies
+it over from the old places (`~/.local/share/moe.senkochan.watch_together`
+or `%APPDATA%\com.example\watch_together`, and the app's files in your
+Documents folder) and leaves the originals where they were.
+
+Update from the app: the app looks for a new version at start and every
+few hours, and when one exists a band across the top of the window says so
+(never over a playing video). "Update and restart" downloads,
+verifies, applies in place and restarts; "Later" hides it until the next
+check; the install folder must be writable by you. The version you run is
+at the bottom of every Settings page (and in the Settings tab's tooltip). Settings has Check now and an auto-check toggle. From a terminal:
+`./starsync-server --upgrade` (no display needed, so it works on a
+server box too), `./starsync --upgrade`, or the shipped `update.sh` /
+`update.bat` (which run the first). Each updates the whole folder, app and
+server; restart whichever is running to use the new version. A
 release with a newer protocol is a required update: everyone on a server
 must run the same protocol version, and a mismatch is refused with a message
 telling you to update.
 
+## Getting started
+
+Three ways in, all at the top of the Library when you are not in a server.
+None of them needs Jellyfin or an account.
+
+- **Join a friend** (most people): your friend sends you an address and,
+  maybe, a password. See [Join](#join).
+- **Host**: you have the video and friends watch it with you. See
+  [Host from the app](#host-from-the-app).
+- **Watch solo**: just play something from the Library. It plays for you
+  alone, with everything a server has (Jellyfin progress, next episode,
+  skip buttons); nothing is reachable from outside this computer. Invite
+  friends in the strip turns it into a hosted server (the Host card's port
+  and password) and the video carries on from where it was; Stop ends it.
+
 ## The window
 
 One window. Along the top, the strip: your avatar (click it for your
 profile: name, picture with a crop editor, colour, and links to the
 settings), the Library / Schedule / Settings tabs, and the party. Offline
-the party side has Join and Host; in a server it shows everyone's avatar
+the party side has Join a friend and Host; watching solo it says Solo,
+with Invite friends and Stop; in a server it shows everyone's avatar
 with a ring for their state (green ready, amber buffering, grey not ready,
-dimmed reconnecting; a crown on whoever hosts, a tower on whoever
-passes the video on). Click the avatars for the member list (force ready,
-kick, "Copy invite address"; when you host it lists this computer's
+a little faded joining, dimmed reconnecting, dimmed with a moon sitting
+out; a crown on whoever
+hosts, a tower on whoever passes the video on). Click the avatars for the
+member list (each member's app version, amber when it differs from yours,
+and the server's at the top; force ready, Nudge, Sit out, "Copy invite address"; when you host it lists this computer's
 network addresses with the port, and friends outside your network need
-that port forwarded or a server they can all reach, like a VPS). Beside them the server and "ready n/m", the chat button with unread
+that port forwarded or a server they can all reach, like a VPS). Beside them the server and "ready n/m" (who is sitting out or
+reconnecting does not count), the chat button with unread
 count, and Leave. Empty strip space drags the window.
 
 The player fills the window under the strip. Pick a tab and it shrinks to
 a mini player in a corner: drag it anywhere and it snaps to the nearest
-corner; double-click or ⤢ makes it big again, × stops watching (you stay in
-the server, muted) and the strip's screen button brings it back. F or
+corner; double-click or ⤢ makes it big again, × sits you out (below) and
+× again closes it; the strip's screen button brings it back. F or
 double-click on the picture goes fullscreen (the strip hides, the party
 shows in a corner while paused, the window buttons sit in the player's top
 bar while its controls are up), Esc leaves it. The controls show the
-show's cover, title and episode top left (guests get the cover too); before
+show's cover, title and episode top left (a web video: its thumbnail and
+name; guests get the art too; right-click to copy the title, or the link
+when you have it, or open it in the browser or Jellyfin); before
 a video first plays, its banner fills the picture until playback starts.
-One pill above the controls says what playback waits for ("Press Space
+One pill bottom centre, just above the controls, says what playback waits for ("Press Space
 when you're ready", "Waiting for Bob and Mika · 2/3 ready", "Bob is
 loading…") or what went wrong, with Retry or Cancel when it helps. Chat and activity open in a panel on the right (chat button or
-Tab), ready to type; it shows messages, and its "Activity" toggle adds
-joins, ready, seeks and the like between them. Joins, leaves, chat and
-other news also pop up bottom left with the person's avatar; click a message to open the chat. Unread chat
-shows as a count on the chat buttons and, in fullscreen with the controls
-hidden, as a small chip top right.
+Tab), ready to type; it shows messages (select text to copy it, or
+right-click for Copy message and, with a link in it, Copy link / Open in
+browser), and its "Activity" toggle adds
+joins, ready, seeks and the like between them. Joins, leaves, someone
+losing connection and coming back, video changes, additions to Up next
+(the title, its picture and who added it), chat and problems also pop up
+bottom left with the person's avatar, above the player's controls (never
+on them); ready, seeks and pauses stay in the activity. Click a message
+to open the chat (Settings → Notifications & sounds → Chat messages: All
+by default, or Only when paused, or Off; messages always reach the chat,
+with their sound). Watching alone, nothing pops up or sounds about the
+party (there is nobody); the app's own notices still show.
+
+**While sitting out or in the background.** Sitting out, only chat,
+nudges, "starting now" (the video starts for the others) and Up next
+reach you; joins and leaves too if you turn on Settings → Notifications &
+sounds → "Joins and leaves too". With the window in the background or
+minimised, the same ones also come as desktop notifications (Linux's
+notification center, Windows' toasts); clicking one brings the window
+up, and a chat one opens the chat. Unread chat shows as a count on the chat
+buttons and, in fullscreen with the controls hidden and the video paused,
+as a small chip top right.
 
 Your name and picture change for everyone in the server right away; the
 colour is yours only.
 
+**Sitting out.** Step away without leaving: Sit out (your profile, your
+row in the member list, or × on the mini player) unloads the video on your
+end, and nobody waits for you any more; you stay in chat. Anyone can sit
+anyone out, the host too ("Alice sat you out" tells you who). The player
+then shows the cover, title and where the others are; Join back (or Space)
+loads the video there and readies you, in the background while the others
+play on (nobody is paused for you).
+
+**Auto sit-out.** Idle for 5 minutes while nothing plays, or the window
+minimised for 10 minutes (playing or not), sits you out by itself, so
+nobody waits for you; you are back as soon as you return (a key, the
+mouse, the window's focus). It never happens when you are alone, and an
+away you chose (or someone else's) stays until you join back. Settings →
+Party & network → "Auto sit-out" turns it off.
+
+**Reconnects.** A bad connection does not throw you out: the video keeps
+playing, the pill says "Connection unstable…" and then "Reconnecting…",
+and the app comes back on its own as the same member (ready, sitting out,
+your Up next items and the video you pass on all kept) for up to 10
+minutes; the others see you dimmed, "reconnecting…". Only a drop of a
+few seconds or more makes the lost / back sounds. Leave and closing the
+app tell the others at once; Update and restart keeps your place for the
+restarted app. Opening Starsync a second time (another window with the
+same profile) takes your place over, and the first one says so and stops.
+
+**Nudge.** Nudge in the member list pokes someone, sitting out or not:
+only they hear it (a sound, a pop-up, and the taskbar entry asks for
+attention when the window is in the background).
+
 ## Host from the app
 
 Host in the strip: set a port and an optional password (blank = anyone can
 join), then Host. The app starts a server inside itself and joins it; you
-are the host and nobody can kick you. Nothing is up yet: pick what to
+are the host (the crown). Nothing is up yet: pick what to
 watch in the Library tab (below) and put it up. Leaving or
 closing the app stops the server. Friends need to reach your machine: open
 the TCP port on your router (or use a LAN or VPN address). Friends open
@@ -88,10 +177,11 @@ disk. Nothing is uploaded or stored anywhere.
 
 What to watch, from three sources (the switch at the top). Drop a video,
 a folder or a link anywhere on the window, or press Ctrl+V outside a
-text field, and a small card asks how to open it (put it up, add the
-folder to Files, or fill Link).
+text field, and a small card asks how to open it (put it up, add it to
+Up next, add the folder to Files, or fill Link).
 
-- **Jellyfin**: your linked servers (see below). Library chips beside the
+- **Jellyfin**: your linked servers (see below); with none linked it
+  points to Files and Link and offers Jellyfin as optional. Library chips beside the
   switch, then one **Continue** row (what you were watching and what comes
   next, one card per series, the one you watched most recently first;
   series not touched for two months drop out) and **Latest in** each
@@ -103,24 +193,84 @@ folder to Files, or fill Link).
   details open on the right with "Put it up · S1E3", mark watched /
   unwatched, remove from Continue and the episode list (click an episode
   to choose it). Double-click a card or an episode to put it up at once.
-- **Link**: paste an http(s) link. The preview shows what it is (title and
-  thumbnail for YouTube, else the file name); in a server, pick how the
+  Right-click a card or an episode to copy its title or open it in
+  Jellyfin's web page (the details panel has that button too).
+- **Link**: paste an http(s) link: a video file, or a web page with a
+  video (YouTube, X, and whatever else yt-dlp knows). The preview shows
+  what it is (a page's title, uploader, length and thumbnail, else the
+  file name); in a server, pick how the
   others get it (everyone fetches it, the server fetches it, or through
-  you). Your last 12 links are listed under it.
+  you). Your last 12 links are listed under it (right-click one to copy
+  or open it). A link seen before shows its preview at once, without
+  asking the site again. A link that does not
+  open here (needs cookies, 403, 404, not a video) says why and goes up
+  only with "Put it up anyway"; in the player, whoever cannot play it is
+  named ("Bob can't play this: Not allowed (403)") and nobody waits for them.
 - **Files**: video folders you add on this computer, grouped by series
   (click a series to list its episodes), or any file through Browse. The others stream it from you.
 
-Put it up and the player opens. Offline the library browses but nothing
-goes up until you join or host ("Join or host to watch together").
+Put it up and the player opens. Not in a server, the buttons say Play
+and it plays for you alone ([Watch solo](#getting-started)).
+
+### Up next (the queue)
+
+In a server (solo too), anything can wait its turn instead of going up
+now: **Add to queue** on the Link page (in the way you picked), or
+right-click a Jellyfin card or episode, a video in Files, a recent link
+or an episode on the Schedule for **Add to queue** / **Play next**; the
+Jellyfin details panel has a queue button (right-click it to play next),
+and the card for a dropped or pasted video or link has both. A link is
+checked first, like Put it up. Every app keeps the next item ready,
+its first seconds already loaded, so skipping to it starts at once.
+For a link passed on, a member's file or a link the server fetches,
+the server starts getting the next item while the current one plays
+(from the app of whoever added it, or by fetching the link itself), so
+everyone has its start before it goes up; whoever added it keeps the
+app open for that. Everyone shares one Up next and anyone can change it; what
+you added stays when you leave.
+
+In the player, Up next sits in the top bar, right of the title: the
+next item's picture and title (or the next episode's). Rest the mouse on
+it for a larger preview (who added it, its length, whether it is ready
+to start); ⏭ plays it now, a click opens the queue: drag rows to reorder, hover a
+row to play it now (▶) or remove it (×), right-click it for more (copy its
+title or link, open it in the browser or in Jellyfin). To add, press
+Ctrl+V with the queue open (a copied link or video file goes in at once,
+its title and picture showing while it is checked), type one after
+**+ Add link**, or drop a link or a video on it. When a video ends, a card shows
+what is up next with a 10 s countdown (Cancel stops it on your screen)
+and it plays; `>` or Shift+N plays it at once. Under the queue,
+**Continues with** shows the next episodes of the Jellyfin series
+playing (greyed: they play only once Up next is empty); **+** adds one,
+**Clear** drops them for this episode.
+
+A link you pass on ("through me") or a file of yours can only be played
+by your app: if you left when its turn comes, it is skipped ("Skipped …:
+Foxyz left"). A Jellyfin item needs someone with an account on that
+server. Up next is kept by the server while it runs; restarting the
+server empties it.
+
+## Schedule
+
+The week's airing anime, one column per day (AniList), each episode
+marked with what the Jellyfin server has of it when AnimeFlow is
+connected (Settings, Jellyfin & integrations): **on Jellyfin** (Put it
+up, right-click to queue), **downloading**, **waiting for release**
+(aired in Japan, AnimeFlow downloads it by itself once a release
+appears; with when AnimeFlow last searched, or **release rejected** when
+it found releases it won't take, the reason on hover), **failed**, **not monitored** (Request asks AnimeFlow for it),
+or the time left until it airs. A show AnimeFlow does not follow can be asked for with **Request
+series**. Episodes you already watched on Jellyfin carry a check on the
+cover; one you started shows how far you got.
 
 ## Dedicated server
 
 For an always-on box (no display needed): the release tarball also contains
-`watch-together-server`, a small standalone server without the app. Run it,
+`starsync-server`, a small standalone server without the app. Run it,
 then everyone (you included) uses Join.
 
 ```
-./watch-together-server --port 8080 --secret <password>
+./starsync-server --port 8080 --secret <password>
 ```
 
 | Flag | Default | Meaning |
@@ -130,13 +280,38 @@ then everyone (you included) uses Join.
 | `--name` | `server` | name reported by `/health` |
 | `--media` | none | local file to serve as the starting video |
 | `--advertise-host` | none | host put in file URLs instead of the one each viewer dialled |
-| `--config` | none | YAML or JSON file with the same settings (`port`, `secret`, `name`, `mediaPath`, `advertiseHost`); replaces the flags |
+| `--[no-]yt-dlp` | on | read web pages (YouTube, X, …) with yt-dlp when the server fetches a link |
+| `--yt-dlp-dir` | next to the binary | writable folder for the server's yt-dlp (systemd: the unit's `StateDirectory`) |
+| `--yt-dlp-cookies` | none | cookies.txt or cookie-extension JSON export for that yt-dlp (sites that refuse guests); copied into the yt-dlp folder at start, removed from it when not given. **An account login**: keep it private, use a throwaway account for YouTube |
+| `--log-dir` | `logs` next to `--config`, else next to the binary (systemd: the unit's `StateDirectory`) | folder for the log files (`server-YYYY-MM-DD.log` and the session log `session-YYYY-MM-DD.log`, kept 7 days; passwords, tokens and cookies left out) |
+| `--config` | none | YAML or JSON file with the same settings (`port`, `secret`, `name`, `mediaPath`, `advertiseHost`, `ytDlp`, `ytDlpDir`, `ytDlpCookies`); replaces the flags |
+| `--upgrade` | | update the install folder to the latest release ([Install and update](#install-and-update)), then exit |
+| `--check-update` | | print whether a newer release exists, then exit |
 
 It prints `READY port=... name=...` once listening and stops cleanly on
-Ctrl+C or SIGTERM. A dedicated server has no host: anyone can kick anyone.
-To run it as a service, unpack the tarball to `/opt/watch-together` and use
-[deploy/watch-together.service](deploy/watch-together.service) (copy it to
-`/etc/systemd/system/`, edit the flags, `systemctl enable --now watch-together`).
+Ctrl+C or SIGTERM. A dedicated server has no host.
+To run it as a service, unpack the tarball to `/opt/starsync` and use
+[deploy/starsync.service](deploy/starsync.service) (copy it to
+`/etc/systemd/system/`, edit the flags, `systemctl enable --now starsync`).
+A service set up before the rename (`/opt/watch-together`, running
+`watch-together-server`) keeps working as it is.
+
+Something not playing? Settings → About → **Copy diagnostics** puts the
+app's recent log (passwords, tokens and cookies left out) on the
+clipboard: paste it to whoever helps you, from both sides if you can.
+
+While you are in a server, the app also sends its log to that server, which
+merges everyone's lines and its own into one session log
+(`session-YYYY-MM-DD.log` next to the server's logs; the hosting app keeps
+it in its own logs folder), so a problem can be read afterwards from every
+side. Chat is never logged anywhere, nor passwords, tokens and cookies.
+When something goes wrong, press **Mark a problem** (Ctrl+Shift+B, also in
+the player's ⚙ and Settings → About) and add a few words if you like: a
+marker with your name goes in the session log at that moment. In a server,
+Copy diagnostics can add the session log of the last 6 hours (any member
+may read it). Don't want to share? Settings → About → **Share diagnostics
+with the server** off: your log stays on your machine (the server only
+notes that you don't share; a problem you mark still goes in).
 
 ## Join
 
@@ -154,52 +329,76 @@ of help: Profile; Party & network (the Host card's default port and
 password, recent servers with remove); Player (below); Jellyfin &
 integrations (linked Jellyfin servers, below, the AnimeFlow connection:
 "connected as <name>" with what you may do, or why not, and playing the
-next episode automatically); Notifications & sounds (what pops up; the sound
-volume, and every sound with a preview and its own switch); Updates; Keyboard shortcuts (read-only); About
-(the version).
+next episode automatically); Notifications & sounds (what pops up, chat
+pop-ups, what reaches you while sitting out or in the background; the sound
+volume and sound set, and every sound with a preview, its own set and a switch); Updates; Keyboard shortcuts (read-only); About
+(the version, also at the bottom of every Settings page and in the
+Settings tab's tooltip; and the credits, e.g. that the Minimal player design is inspired by uosc).
 
-Player settings live in the player: ⚙ at the right end of its controls
-(both designs) opens them, and Settings → Player has the same ones (plus
-the custom shader files). Player design: Standard or uosc (below);
-progress line when hidden (on by default: a 2 px line at the bottom of
-the video while the controls are hidden); upscaling shader (see below);
-hardware decoding (auto, off or custom; the env var `SYNC_RELAY_HWDEC`
-overrides it); in the player also the subtitle and audio track. Every
-change applies right away.
+Player settings live in the player too: ⚙ → Player settings, at the
+right of its controls, and Settings → Player has the same ones (plus the
+controls' layout and the custom shader files). Player design: Standard or
+Minimal (below); progress line when hidden (on by default: a thin line at
+the bottom of the video while the controls are hidden); upscaling shader
+(see below); hardware decoding (auto, off or custom; auto is mpv's
+`auto-copy` on Windows, `auto` elsewhere; the env var
+`SYNC_RELAY_HWDEC` overrides it); in the player also the subtitle and
+audio track. Settings → Player → Controls: time display (elapsed / total
+or remaining), controls size (normal or large), hide the controls after
+2, 3 or 5 s, and which optional buttons sit in the bar (chapter buttons,
+subtitles, audio, chat; hidden ones are still in ⚙). Every change
+applies right away.
 
 Anywhere in a server (unless you are typing): Space = ready / unready,
-Tab = chat & activity (Tab never moves between buttons). Keys while the
+Tab = chat & activity (Tab never moves between buttons). Anywhere:
+Ctrl+Shift+B = mark a problem in the session log. Keys while the
 player fills the window: Left/Right = seek 10 s, Up/Down = volume, Shift+Right = skip 1:30,
 PgUp/PgDn = previous / next chapter (as in mpv), F = fullscreen, Esc =
-close the chat or fullscreen, else ask to leave, Ctrl+R = reload video,
+close the chat, then fullscreen, then shrink the player to mini; from the
+mini it asks to leave, Ctrl+R = reload video,
 `<` / `>` or Shift+P / Shift+N = previous / next Jellyfin episode,
 Ctrl+1..6 = Anime4K mode A, B, C, A+A, B+B, C+A, Ctrl+0 = shaders off.
 Every seek, skip and chapter jump moves everyone.
 
-Controls: the seek bar marks chapter starts with a diamond; hovering it
-shows the time and the chapter title. The chapters button lists them
-(current one checked; click to jump). "1:30" skips ahead 1:30. Audio and
-Subtitles buttons (with the track count) list tracks as "Japanese · E-AC3
-2.0 · title"; subtitles have Off. Volume (hover the speaker, scroll on
-it, or Up/Down) goes to 150 % like mpv: past the tick at 100 % the bar
-turns amber and mpv amplifies.
+Controls: both designs have the same buttons in the same places, only
+the look differs. Bottom left: play / pause first (it is your ready, like
+Space: ✓ while you are ready and the others are not), previous / next
+episode (when there is one; next plays Up next first), previous / next
+chapter (when the video has chapters), volume and the time (click it to
+switch between elapsed / total and the time left). Bottom right:
+Subtitles and Audio (with the track count; tracks listed as "Japanese ·
+E-AC3 2.0 · title", subtitles with Off), ⚙, chat and fullscreen last.
+Everything else is in ⚙: chapters (current one checked; click to jump),
+Skip 1:30, upscaling shader, change video, copy link, reload video,
+mark everyone ready, mark a problem, player settings and leave. The top
+bar has the title, Up next and back to the library (in fullscreen: exit
+fullscreen and the window buttons). Volume (scroll anywhere on the
+video, hover the speaker, or Up/Down) goes to 150 % like mpv: past the
+tick at 100 % the bar turns amber and mpv amplifies; a scroll or key
+shows the volume for a moment. Lists and menus under the mouse scroll
+as usual.
 
-The uosc player design (⚙ → Player design, Standard by default,
-switches right away): video controls modeled on mpv's uosc theme. A thick
-timeline across the bottom shows the played part, the cached part ahead
-(hatched), chapter starts as diamonds and the time; hovering it shows the
-chapter title and the time there. With the controls hidden it stays as a
-thin line (unless "Progress line when hidden" is off). Above it flat buttons: ≡ menu, Subtitles and Audio (with the
-track count), the shader badge (the active Anime4K mode, e.g. "A HQ"),
-ready, chapters, 1:30, previous / next episode, change video, volume, ⚙
-and fullscreen; the title top left, chat and back-to-library top right. Keys and skip buttons work
-the same.
+Standard (the default): a seek bar that marks chapter starts with a
+diamond (hovering it shows the time and the chapter title) over a row
+of round buttons. Minimal (⚙ → Player settings → Player design, switches
+right away): a translucent timeline across the bottom tints what has
+played, stripes the part not downloaded yet, marks chapter starts with
+dots (click one to jump), shows the elapsed time left and the total or
+the time left right (click it to switch) and, while less than a minute
+is buffered, the buffered seconds next to the position; hovering it shows
+the time there and the chapter title. With the controls hidden it stays
+as a thin line (unless "Progress line when hidden" is off). Its buttons
+sit in two glass capsules above it. Minimal's timeline and controls are
+inspired by [uosc](https://github.com/tomasklaen/uosc) by tomasklaen
+(LGPL-2.1).
 
-Skipping: during the opening a "Skip OP" button floats in the corner (it
+Skipping: during the opening a "Skip OP" button shows bottom right, just
+above the controls (it
 jumps to the end of the opening), during the ending "Skip ED" (to the end
-of the ending only; what comes after is yours to skip). Any skip button
-(also "Skip 1:30") shows for 5 seconds when it comes up, then only while
-the controls are up (move the mouse). The opening and
+of the ending only; what comes after is yours to skip). "Skip OP" and
+"Skip 1:30" show for 5 seconds when they come up, then only while the
+controls are up (move the mouse); "Skip ED" and "Next episode" show only
+while the controls are up. The opening and
 ending come from Jellyfin's intro / outro segments when your Jellyfin has
 them (needs a segment plugin, e.g. Intro Skipper), else from chapter names
 (OP, Opening, Intro / ED, Ending, Credits, Outro). Without an opening or
@@ -246,11 +445,14 @@ Watching:
   directly with their own sign-in. Jellyfin tracks progress per account:
   your watched state, Continue watching and resume point follow what you
   saw (reported on start, every 10 s, on pause, resume, seek and track
-  change, and when it stops).
+  change, and when it stops). Watched means you actually played most of
+  it (or reached the ending after half), not where you stopped: opening
+  a watched episode to check a moment keeps it watched, and a quick peek
+  leaves no resume point.
 - Friends without an account watch through the server: whoever put the
   item up passes it on automatically, with their own sign-in, which never
   leaves their computer (only the current item, only to people in the
-  session). They show "via host" in the member list (click the avatars). When the app hosts,
+  session). They show "via server" in the member list (click the avatars). When the app hosts,
   or a dedicated server has its own login (`--jellyfin <file>`, see
   [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md), Jellyfin relay), the server
   fetches it itself instead.
@@ -258,10 +460,11 @@ Watching:
   "No Jellyfin account here for ..." with a button to link one; it plays as
   soon as you are signed in.
 
-Episodes: the ⏮ / ⏭ buttons next to the controls (or `<` / `>`,
+Episodes: the ⏮ / ⏭ buttons next to play (or `<` / `>`,
 Shift+P / Shift+N) put up the previous or next episode for everyone. From
 the ending (when it is known, see Skipping above; else in the last two
-minutes) a "Next episode" button floats in the corner. When an
+minutes) a "Next episode" button floats in the corner while the controls
+are up. When an
 episode ends, a card shows what is next with Play next; with "Play the
 next episode automatically" (Settings, on by default) it counts down 10 s
 first, and Cancel stops it on your screen (seeking back stops it for
@@ -273,26 +476,55 @@ Your choice is remembered per series (and as a default) and the closest
 match (language, then title, then codec and channels) is selected on the
 next episode. This is per person; nobody else is affected.
 
-"Change video" in the player's controls opens the Library tab (the player
+⚙ → Change video in the player opens the Library tab (the player
 goes mini): the library starts on the series you are watching with the
 current season, else where you left it.
 
 Anyone can put up a file from their own computer, also on a dedicated
 server: it streams from your computer through the server to everyone (the
 server keeps a few minutes in memory, so seeks and skipping the opening
-are quick). Keep the app open while it plays. For a link you choose how
-the others get it:
-- Everyone fetches it (default): each app plays the link itself.
+are quick). Keep the app open while it plays. A link goes up "Through
+me": your computer opens it and passes it on, so it plays for everyone
+whenever it plays for you (you can't tell ahead which sites want cookies,
+and YouTube may start asking any day). Under "Other ways" there are two more:
+- Everyone fetches it: each app plays the link itself.
 - Server fetches it: the server downloads it once for everyone, for links
   that are slow or blocked for some. The server must be able to reach it,
   and it must have a password (an open server refuses: anyone could make
   it fetch addresses only it can reach).
-- Through me: your computer downloads it and passes it on, for links only
-  you can open.
 
-The last two need a link to a video file (not a page like YouTube) and
-never show the link to anyone. Your upload has to beat the video's
-bitrate: a 25-minute 2 GB episode is about 11 Mbit/s.
+Web pages work in all three: the app and the dedicated server each
+download [yt-dlp](https://github.com/yt-dlp/yt-dlp) by themselves (checked
+against the release's checksums, updated once a day; Settings → Player
+shows its version and has "Update now"), so there is nothing to install.
+Sites that refuse guests (Bilibili answers "HTTP Error 412", YouTube may
+ask to sign in) need cookies: Settings → Player → yt-dlp → Cookies reads
+them from a browser, or from a cookies.txt or a cookie extension's JSON
+export (picked or dropped; every site in it is kept). They stay on this
+computer and are used by its yt-dlp only (your own playback, "through
+me", and a server you host). Cookies log yt-dlp in as you on those
+sites: keep the file private, and for YouTube consider a throwaway
+account (Google may flag accounts used with yt-dlp).
+YouTube works in all three too, and so do pages and links that only
+offer streaming playlists (HLS `.m3u8`, DASH `.mpd`, the HLS of X videos).
+Through me and Server fetches it never show the link to anyone; they can't pass on live
+streams or DRM-protected video (use "Everyone fetches it" for live).
+Your upload has to beat the video's bitrate: a 25-minute 2 GB episode is
+about 11 Mbit/s.
+
+The member list (click the avatars) shows where the video comes from on
+top: who passes it on, or that the server fetches it, everyone plays the
+link, or everyone streams it from Jellyfin, with how many watch through
+the server and, for a relay, how fast it arrives against what the video
+needs (the bar's mark; past it is keeping up). It turns amber when the
+source is too slow or its connection dropped ("Bob's connection dropped —
+playing what the server has (2 min)"), red when it left (the others play
+out what the server already has; the player's pill says the same and a
+pop-up tells you once), and whoever passes it on is told once when their
+upload is too slow. Each member's line says how they get it
+("via server" with their speed, or "direct") after a dot for their
+buffer: green enough to play on, amber low, red empty. A red dot on one
+member while the source keeps up is their own connection.
 
 ## Video quality and shaders
 
@@ -302,9 +534,9 @@ affected. The app ships [Anime4K](https://github.com/bloc97/Anime4K) v4.0.1
 C (480p), A+A, B+B, C+A, each as HQ (strong GPUs, GTX 1080 and up) or Fast
 (the guide's low-end set). "Custom shaders" runs your own `.glsl` files.
 
-Pick one with the ✨ button in the player's control bar (also in
+Pick one with ⚙ → Upscaling shader in the player (also in
 fullscreen) or Ctrl+0..6; the change applies live and is saved, so the next
-session starts with it. The player's ⚙ and Settings → Player set it too,
+session starts with it. ⚙ → Player settings and Settings → Player set it too,
 with HQ or Fast (used by Ctrl+1..6); Settings → Player holds the custom
 files. Shaders cost GPU time
 every frame and need hardware video rendering: on media_kit's software
@@ -316,7 +548,7 @@ fails to load shows a toast and switches shaders off.
 - "host offline - check address and port": wrong address, or the port is not open.
 - "wrong server password": password mismatch.
 - "host runs a different version": update the app on both sides.
-- Picture frozen but sound fine: Ctrl+R reloads the video; the app also does it automatically.
+- Picture frozen but sound fine: Ctrl+R reloads the video.
 - Everyone waits at "waiting for X": X has not buffered 4 seconds yet or has not pressed Space.
 - Windows: the build is new; if something is off there, say so.
 

apps/desktop/assets/icon/icon.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256">
+<defs><linearGradient id="bg" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#2d2547"/><stop offset="1" stop-color="#14111d"/></linearGradient><linearGradient id="t1" gradientUnits="userSpaceOnUse" x1="50.7" y1="148.7" x2="184.6" y2="71.4"><stop offset="0" stop-color="#f0795a" stop-opacity="0"/><stop offset="0.45" stop-color="#f0795a" stop-opacity="0.85"/><stop offset="1" stop-color="#ffc56b"/></linearGradient><linearGradient id="t2" gradientUnits="userSpaceOnUse" x1="205.3" y1="107.3" x2="71.4" y2="184.6"><stop offset="0" stop-color="#ffc56b" stop-opacity="0"/><stop offset="0.45" stop-color="#ffc56b" stop-opacity="0.85"/><stop offset="1" stop-color="#f0795a"/></linearGradient></defs>
+<rect x="8" y="8" width="240" height="240" rx="56" fill="url(#bg)"/>
+<circle cx="128" cy="128" r="80" fill="none" stroke="#ffffff" stroke-opacity="0.10" stroke-width="6"/>
+<path d="M205.27 107.29 A80 80 0 0 1 71.43 184.57" fill="none" stroke="url(#t2)" stroke-width="7" stroke-linecap="butt"/><path d="M50.73 148.71 A80 80 0 0 1 184.57 71.43" fill="none" stroke="url(#t1)" stroke-width="7" stroke-linecap="butt"/>
+<path d="M110 96 L110 160 L162 128 Z" fill="#fff1d6" stroke="#fff1d6" stroke-width="16" stroke-linejoin="round"/>
+<path d="M71.4 161.6 Q74.7 181.3 94.4 184.6 Q74.7 187.8 71.4 207.6 Q68.2 187.8 48.4 184.6 Q68.2 181.3 71.4 161.6 Z" fill="#f0795a"/>
+<path d="M184.6 40.4 Q188.9 67.1 215.6 71.4 Q188.9 75.8 184.6 102.4 Q180.2 75.8 153.6 71.4 Q180.2 67.1 184.6 40.4 Z" fill="#ffc56b"/>
+</svg>

apps/desktop/lib/app.dart

@@ -3,6 +3,7 @@ import 'package:flutter/material.dart';
 import 'src/screens/home/ui.dart';
 import 'src/shell/app_shell.dart';
 import 'src/widgets/app_keys.dart';
+import 'src/widgets/app_menu.dart';
 
 class WatchTogetherApp extends StatelessWidget {
   const WatchTogetherApp({super.key});
@@ -11,7 +12,9 @@ class WatchTogetherApp extends StatelessWidget {
   Widget build(BuildContext context) {
     return MaterialApp(
       title: appName,
-      theme: ThemeData.dark(),
+      // Material's own menus (the player's track menus, sort) wear the
+      // app menu's surface.
+      theme: AppMenuStyle.theme(ThemeData.dark()),
       shortcuts: appShortcuts,
       home: const AppKeys(child: AppShell()),
     );

apps/desktop/lib/main.dart

@@ -1,16 +1,21 @@
+import 'dart:async';
 import 'dart:io';
 
 import 'package:flutter/material.dart';
 import 'package:hive_ce_flutter/hive_flutter.dart';
 import 'package:media_kit/media_kit.dart';
 import 'package:sync_relay_core/core.dart';
-import 'package:window_manager/window_manager.dart';
 
 import 'app.dart';
+import 'src/platform/app_log.dart';
+import 'src/platform/app_shutdown.dart';
+import 'src/platform/desktop/desktop_app_dirs.dart';
+import 'src/platform/desktop_entry.dart';
 import 'src/screens/home/ui.dart';
+import 'src/session/app_events.dart' show UpdateAvailable;
 import 'src/state/session_state.dart';
 import 'src/state/settings.dart';
-import 'src/update/updater.dart';
+import 'src/update/update_controller.dart' show UpdateController, UpdatePhase, launchArgs;
 
 Future<void> main(List<String> args) async {
   launchArgs = List.unmodifiable(args);
@@ -37,47 +42,42 @@ Future<void> main(List<String> args) async {
         ),
       );
   WidgetsFlutterBinding.ensureInitialized();
-  await windowManager.ensureInitialized();
-  await windowManager.setPreventClose(true);
-  windowManager.addListener(_CloseGuard());
-  const windowOptions = WindowOptions(
-    size: Size(1280, 720),
-    minimumSize: Size(160, 90),
-    center: true,
-    backgroundColor: Color(0xFF000000),
-    titleBarStyle: TitleBarStyle.hidden,
-    title: appName,
-  );
-  windowManager.waitUntilReadyToShow(windowOptions, () async {
-    await windowManager.show();
-    await windowManager.focus();
-  });
-  await Hive.initFlutter();
+  final dirs = await const DesktopAppDirs().resolve();
+  await startAppLogging(dirs);
+  Hive.init(dirs.hive);
   await AppSettings.instance.ensureLoaded();
+  // Close button / Alt+F4: the orderly close ([shutDownApp]), so others
+  // see "left", a hosted server shuts down and no player outlives the
+  // engine.
+  final ports = SessionState.instance.ports;
+  await ports.shell.start(
+      title: dirs.profile == null ? appName : '$appName [${dirs.profile}]', onCloseRequest: shutDownApp);
+  // Focus, minimise and restore feed auto sit-out and the Notifier (in
+  // the background, notices go out as system notifications).
+  ports.shell.watchActivity((a) {
+    SessionState.instance.coordinator.windowActivity(a);
+    SessionState.instance.notifier.window = a;
+  });
   try {
     await SessionState.instance.loadForm();
   } catch (e, st) {
     debugPrint('load connect form failed: $e\n$st');
   }
   MediaKit.ensureInitialized();
-  runApp(const WatchTogetherApp());
-}
-
-/// Close button / Alt+F4: leave gracefully first (others see "left", a
-/// hosted server shuts down), bounded so a hung socket can't keep the
-/// window open.
-class _CloseGuard with WindowListener {
-  bool _closing = false;
-
-  @override
-  Future<void> onWindowClose() async {
-    if (_closing) return;
-    _closing = true;
-    try {
-      await SessionState.instance.leave().timeout(const Duration(seconds: 2));
-    } catch (e) {
-      debugPrint('leave on close failed: $e');
+  // yt-dlp for web page links: downloaded on first run, kept current.
+  ports.links.warmUp();
+  // Linux: the launcher entry and icon Wayland needs (release installs).
+  unawaited(installDesktopEntry());
+  // A found update is an event too (the band shows it).
+  final updates = UpdateController.instance;
+  updates.status.addListener(() {
+    final s = updates.status.value;
+    final version = s.manifest?.version;
+    if (s.phase == UpdatePhase.available && version != null) {
+      SessionState.instance.notifier.notify(UpdateAvailable(version));
     }
-    await windowManager.destroy();
-  }
+  });
+  runApp(const WatchTogetherApp());
+  // The sound device opens once the window is up, not on the first sound.
+  Future.delayed(const Duration(seconds: 2), SessionState.instance.sfx.warmUp);
 }

apps/desktop/lib/src/controls/control_menus.dart

@@ -0,0 +1,136 @@
+import 'package:flutter/material.dart';
+import 'package:sync_relay_core/core.dart' show JellyfinStreamType;
+
+import '../jellyfin/track_prefs.dart' show MpvTrack;
+import '../playback/media_marks.dart';
+import '../shaders/shader_menu.dart';
+import '../shell/mark_problem.dart';
+import '../state/settings.dart';
+import '../widgets/app_menu.dart';
+import '../widgets/copy_open.dart';
+import 'frame.dart';
+import 'model/controls_layout.dart';
+import 'model/controls_model.dart';
+import 'player_settings.dart';
+
+// The controls' menus, shared by both skins: the track and chapter lists
+// and the ⚙ menu, all on the app's menu (`showAppMenu`), anchored on the
+// button that opens them. Each keeps the controls up while open.
+
+/// How many tracks of [type] there are.
+int trackCount(List<MpvTrack> tracks, JellyfinStreamType type) => tracks.where((t) => t.type == type).length;
+
+/// The audio or subtitle tracks ("Japanese · E-AC3 2.0 · title"), mpv's
+/// selection checked; subtitles start with Off.
+List<AppMenuItem<TrackPick>> trackMenuItems(JellyfinStreamType type, List<MpvTrack> tracks) {
+  final audio = type == JellyfinStreamType.audio;
+  final list = tracks.where((t) => t.type == type).toList();
+  return [
+    if (!audio)
+      AppMenuItem(
+        key: const ValueKey('track-off'),
+        value: (aid: null, sid: null, subtitlesOff: true),
+        label: 'Off',
+        checked: !list.any((t) => t.selected),
+      ),
+    if (audio && list.isEmpty)
+      const AppMenuItem(value: (aid: null, sid: null, subtitlesOff: false), label: 'None', enabled: false),
+    for (final t in list)
+      AppMenuItem(
+        key: ValueKey('track-${t.type.name}-${t.id}'),
+        value: audio ? (aid: t.id, sid: null, subtitlesOff: false) : (aid: null, sid: t.id, subtitlesOff: false),
+        label: t.label,
+        checked: t.selected,
+      ),
+  ];
+}
+
+/// Chapters with their start times, the playing one checked.
+List<AppMenuItem<MediaChapter>> chapterMenuItems(List<MediaChapter> chapters, int? current) => [
+  for (final c in chapters)
+    AppMenuItem(
+      key: ValueKey('chapter-${c.index}'),
+      value: c,
+      label: c.title.isEmpty ? 'Chapter ${c.index + 1}' : c.title,
+      hint: formatClock(c.start),
+      checked: c.index == current,
+    ),
+];
+
+Future<T?> _menu<T>(BuildContext context, PlayerControlsModel model, List<AppMenuItem<T>> items) async {
+  model.menusOpen++;
+  try {
+    return await showAppMenu<T>(context, items: items);
+  } finally {
+    model.menusOpen--;
+  }
+}
+
+/// The audio or subtitle list; a pick is applied (and remembered).
+Future<void> openTrackMenu(BuildContext context, PlayerControlsModel model, JellyfinStreamType type) async {
+  final pick = await _menu(context, model, trackMenuItems(type, model.tracks.peek()));
+  if (pick != null) model.pickTrack(pick);
+}
+
+/// The chapter list; a pick jumps there for everyone.
+Future<void> openChapterMenu(BuildContext context, PlayerControlsModel model) async {
+  final pick = await _menu(context, model, chapterMenuItems(model.chapters.peek(), model.currentChapter.peek()));
+  if (pick != null) model.pickChapter(pick);
+}
+
+/// The ⚙ menu: every action that is not a bar button.
+Future<void> openControlsMenu(BuildContext context, PlayerControlsModel model) async {
+  final s = AppSettings.instance;
+  final shader = shaderShortLabel(s.shaderPreset.peek(), s.shaderQuality.peek()) ?? 'Off';
+  final pick = await _menu(context, model, [
+    for (final a in model.menu())
+      AppMenuItem(
+        key: ValueKey('controls-menu-${a.name}'),
+        value: a,
+        label: a.label,
+        hint: a == ControlAction.shaders ? shader : a.hint,
+      ),
+  ]);
+  if (pick != null && context.mounted) await runControlAction(context, model, pick);
+}
+
+/// Runs a ⚙ menu action; [context] anchors what it opens next.
+Future<void> runControlAction(BuildContext context, PlayerControlsModel model, ControlAction action) async {
+  switch (action) {
+    case ControlAction.chapters:
+      await openChapterMenu(context, model);
+    case ControlAction.subtitles:
+      await openTrackMenu(context, model, JellyfinStreamType.subtitle);
+    case ControlAction.audio:
+      await openTrackMenu(context, model, JellyfinStreamType.audio);
+    case ControlAction.skipForward:
+      model.skipForward();
+    case ControlAction.shaders:
+      model.menusOpen++;
+      try {
+        await ControlsFrame.holdWhile(
+          context,
+          () => showShaderMenu(context, renderMode: model.renderMode, onPick: model.pickShader),
+        );
+      } finally {
+        model.menusOpen--;
+      }
+    case ControlAction.chat:
+      model.toggleChat();
+    case ControlAction.changeVideo:
+      model.changeVideo();
+    case ControlAction.copyLink:
+      final link = model.link();
+      if (link != null) await copyToClipboard(link, done: 'Link copied');
+    case ControlAction.reload:
+      model.reload();
+    case ControlAction.markAllReady:
+      model.markAllReady();
+    case ControlAction.markProblem:
+      await ControlsFrame.holdWhile(context, () => showMarkProblem(context));
+    case ControlAction.playerSettings:
+      await showPlayerSettings(context, renderMode: model.renderMode);
+    case ControlAction.leave:
+      model.leave();
+  }
+}

apps/desktop/lib/src/controls/controls_probe.dart

@@ -2,57 +2,74 @@ import 'dart:async';
 
 import 'package:flutter/material.dart';
 
-/// Follows whether media_kit's desktop controls around [child] are up,
-/// by the same rule they use: up on mount and on any mouse movement,
-/// down [hideAfter] later or when the mouse leaves. media_kit does not
-/// expose its visibility; this lets the player draw a progress line while
-/// they are down. Never takes input.
-class ControlsHoverProbe extends StatefulWidget {
-  final ValueNotifier<bool> shown;
-  final Duration hideAfter;
-  final Widget child;
-  const ControlsHoverProbe({super.key, required this.shown, required this.hideAfter, required this.child});
+/// What keeps the player's controls up besides the mouse on them: the
+/// mouse on a floating element over the picture (a pill, a card, the
+/// status pill: [ControlsHoldRegion]) or an open popover. While anything
+/// holds, the controls stay up; on release they hide on their usual
+/// countdown. Both skins follow it (through `ControlsFrame`).
+class ControlsHold extends ChangeNotifier {
+  final _by = <Object>{};
+  bool _told = false;
+  bool _queued = false;
+  bool _disposed = false;
 
-  @override
-  State<ControlsHoverProbe> createState() => _ControlsHoverProbeState();
-}
+  bool get held => _told;
 
-class _ControlsHoverProbeState extends State<ControlsHoverProbe> {
-  Timer? _timer;
-
-  @override
-  void initState() {
-    super.initState();
-    // Not during this build: the line listening to [shown] may be built.
-    WidgetsBinding.instance.addPostFrameCallback((_) {
-      if (mounted) _wake();
+  /// [who] holds ([on]) or lets go. Listeners hear it in a microtask, never
+  /// during a build or a dispose.
+  void set(Object who, bool on) {
+    if (on ? !_by.add(who) : !_by.remove(who)) return;
+    if (_queued) return;
+    _queued = true;
+    scheduleMicrotask(() {
+      _queued = false;
+      if (_disposed) return;
+      final now = _by.isNotEmpty;
+      if (now == _told) return;
+      _told = now;
+      notifyListeners();
     });
   }
 
   @override
   void dispose() {
-    _timer?.cancel();
+    _disposed = true;
     super.dispose();
   }
+}
 
-  void _wake() {
-    widget.shown.value = true;
-    _timer?.cancel();
-    _timer = Timer(widget.hideAfter, _hide);
-  }
+/// The mouse on [child] counts as the mouse on the controls: it holds
+/// [hold] while it is there.
+class ControlsHoldRegion extends StatefulWidget {
+  final ControlsHold? hold;
+  final Widget child;
+  const ControlsHoldRegion({super.key, required this.hold, required this.child});
 
-  void _hide() {
-    _timer?.cancel();
-    if (mounted) widget.shown.value = false;
+  @override
+  State<ControlsHoldRegion> createState() => _ControlsHoldRegionState();
+}
+
+class _ControlsHoldRegionState extends State<ControlsHoldRegion> {
+  @override
+  void didUpdateWidget(ControlsHoldRegion oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    if (oldWidget.hold != widget.hold) oldWidget.hold?.set(this, false);
   }
 
   @override
-  Widget build(BuildContext context) => MouseRegion(
-        opaque: false,
-        hitTestBehavior: HitTestBehavior.translucent,
-        onEnter: (_) => _wake(),
-        onHover: (_) => _wake(),
-        onExit: (_) => _hide(),
-        child: widget.child,
-      );
+  void dispose() {
+    widget.hold?.set(this, false);
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final hold = widget.hold;
+    if (hold == null) return widget.child;
+    return MouseRegion(
+      onEnter: (_) => hold.set(this, true),
+      onExit: (_) => hold.set(this, false),
+      child: widget.child,
+    );
+  }
 }

apps/desktop/lib/src/controls/frame.dart

@@ -0,0 +1,216 @@
+import 'dart:async';
+
+import 'package:flutter/gestures.dart' show kPrimaryMouseButton;
+import 'package:flutter/material.dart';
+
+import 'controls_probe.dart' show ControlsHold;
+
+// The frame both control skins live in: when the controls are up, and the
+// double-click on the picture. Mouse movement shows them; [hideAfter]
+// without any (or the mouse leaving) hides them and the cursor. Holds keep
+// them up: a seek drag (no hover events arrive), an open menu (a route
+// takes the mouse), and the session's [ControlsHold] (the mouse on a
+// floating pill or card, the Up next popover).
+
+class ControlsFrame extends StatefulWidget {
+  /// Draws the controls; [visible] false while they are hidden.
+  final Widget Function(BuildContext context, bool visible) builder;
+  final VoidCallback? onDoubleClick;
+
+  /// Bands at the top and bottom where a double-click is the bars', not
+  /// the picture's.
+  final double barTop;
+  final double barBottom;
+  final Duration hideAfter;
+
+  /// Follows whether the controls are up (for overlays outside them).
+  final ValueNotifier<bool>? shown;
+
+  /// Keeps them up while held.
+  final ControlsHold? holdBy;
+  const ControlsFrame({
+    super.key,
+    required this.builder,
+    this.onDoubleClick,
+    this.barTop = 0,
+    this.barBottom = 0,
+    this.hideAfter = const Duration(seconds: 3),
+    this.shown,
+    this.holdBy,
+  });
+
+  /// The frame around [context], for widgets that keep it up (a drag, a
+  /// menu).
+  static ControlsFrameState? maybeOf(BuildContext context) => context.findAncestorStateOfType<ControlsFrameState>();
+
+  /// Runs [open] (a menu, a popover) with the controls around [context]
+  /// held up, if there are any.
+  static Future<T> holdWhile<T>(BuildContext context, Future<T> Function() open) {
+    final frame = maybeOf(context);
+    return frame == null ? open() : frame.holdDuring(open);
+  }
+
+  /// The fade of the controls.
+  static const fade = Duration(milliseconds: 150);
+
+  @override
+  State<ControlsFrame> createState() => ControlsFrameState();
+}
+
+class ControlsFrameState extends State<ControlsFrame> {
+  bool _visible = true;
+  int _holds = 0;
+  bool _heldBy = false;
+  Timer? _timer;
+
+  bool get visible => _visible;
+
+  @override
+  void initState() {
+    super.initState();
+    widget.holdBy?.addListener(_holdByChanged);
+    // Not during this build: an overlay listening to [shown] may be built.
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      if (mounted) widget.shown?.value = true;
+    });
+    _hideLater();
+  }
+
+  @override
+  void didUpdateWidget(ControlsFrame oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    if (oldWidget.holdBy != widget.holdBy) {
+      oldWidget.holdBy?.removeListener(_holdByChanged);
+      widget.holdBy?.addListener(_holdByChanged);
+      _holdByChanged();
+    }
+    if (oldWidget.hideAfter != widget.hideAfter && _visible) _hideLater();
+  }
+
+  @override
+  void dispose() {
+    widget.holdBy?.removeListener(_holdByChanged);
+    _timer?.cancel();
+    super.dispose();
+  }
+
+  void _holdByChanged() {
+    final on = widget.holdBy?.held ?? false;
+    if (on == _heldBy || !mounted) return;
+    _heldBy = on;
+    hold(on);
+  }
+
+  /// Show the controls and restart the hide countdown.
+  void wake() {
+    if (!_visible && mounted) {
+      setState(() => _visible = true);
+      widget.shown?.value = true;
+    }
+    _hideLater();
+  }
+
+  /// Keep the controls up while [on] (paired calls).
+  void hold(bool on) {
+    _holds = on ? _holds + 1 : (_holds - 1).clamp(0, 1 << 20);
+    wake();
+  }
+
+  /// Runs [open] (a menu) with the controls held up.
+  Future<T> holdDuring<T>(Future<T> Function() open) async {
+    hold(true);
+    try {
+      return await open();
+    } finally {
+      if (mounted) hold(false);
+    }
+  }
+
+  void _hideLater() {
+    _timer?.cancel();
+    _timer = Timer(widget.hideAfter, _hide);
+  }
+
+  void _hide() {
+    if (!mounted || _holds > 0 || !_visible) return;
+    setState(() => _visible = false);
+    widget.shown?.value = false;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return MouseRegion(
+      cursor: _visible ? SystemMouseCursors.basic : SystemMouseCursors.none,
+      onEnter: (_) => wake(),
+      onHover: (_) => wake(),
+      onExit: (_) {
+        _timer?.cancel();
+        _hide();
+      },
+      child: Stack(
+        fit: StackFit.expand,
+        children: [
+          if (widget.onDoubleClick != null)
+            Positioned.fill(
+              child: DoubleClickListener(
+                onDoubleClick: widget.onDoubleClick!,
+                skipTop: _visible ? widget.barTop : 0,
+                skipBottom: _visible ? widget.barBottom : 0,
+                child: const ColoredBox(color: Color(0x00000000), child: SizedBox.expand()),
+              ),
+            ),
+          widget.builder(context, _visible),
+        ],
+      ),
+    );
+  }
+}
+
+/// Double-click on the picture (not on the bars) without joining the
+/// gesture arena, so single clicks on buttons stay instant.
+class DoubleClickListener extends StatefulWidget {
+  final VoidCallback onDoubleClick;
+  final double skipTop, skipBottom;
+  final Widget child;
+  const DoubleClickListener({
+    super.key,
+    required this.onDoubleClick,
+    this.skipTop = 0,
+    this.skipBottom = 0,
+    required this.child,
+  });
+
+  @override
+  State<DoubleClickListener> createState() => _DoubleClickListenerState();
+}
+
+class _DoubleClickListenerState extends State<DoubleClickListener> {
+  DateTime? _last;
+  Offset? _lastAt;
+
+  void _down(PointerDownEvent e) {
+    if (e.buttons != kPrimaryMouseButton) return;
+    final h = context.size?.height ?? 0;
+    final y = e.localPosition.dy;
+    if (y < widget.skipTop || y > h - widget.skipBottom) {
+      _last = null;
+      return;
+    }
+    final now = DateTime.now();
+    final last = _last, at = _lastAt;
+    if (last != null &&
+        at != null &&
+        now.difference(last) < const Duration(milliseconds: 400) &&
+        (e.localPosition - at).distance < 24) {
+      _last = null;
+      widget.onDoubleClick();
+      return;
+    }
+    _last = now;
+    _lastAt = e.localPosition;
+  }
+
+  @override
+  Widget build(BuildContext context) =>
+      Listener(behavior: HitTestBehavior.translucent, onPointerDown: _down, child: widget.child);
+}

apps/desktop/lib/src/controls/minimal/minimal_controls.dart

@@ -0,0 +1,250 @@
+import 'package:flutter/material.dart';
+import 'package:signals/signals_flutter.dart';
+import 'package:sync_relay_core/core.dart' show JellyfinStreamType;
+
+import '../../queue/queue_ui.dart';
+import '../../shell/now_playing_title.dart';
+import '../../state/settings.dart';
+import '../control_menus.dart';
+import '../controls_probe.dart' show ControlsHold;
+import '../frame.dart';
+import '../model/controls_layout.dart';
+import '../model/controls_model.dart';
+import '../model/controls_prefs.dart';
+import '../volume.dart';
+import 'style.dart';
+import 'timeline.dart';
+
+// The Minimal skin (inspired by mpv's uosc): a timeline band across the
+// bottom that carries the clock, and above it the buttons in two glass
+// capsules, in the layout's order. Top: what plays, Up next and the window
+// controls. Hidden, the band shrinks to a thin progress line (unless
+// switched off).
+
+class MinimalControls extends StatelessWidget {
+  final PlayerControlsModel model;
+  final bool visible;
+  final double scale;
+  final ControlsHold? hold;
+  final Widget? windowButtons;
+  const MinimalControls({
+    super.key,
+    required this.model,
+    required this.visible,
+    this.scale = 1,
+    this.hold,
+    this.windowButtons,
+  });
+
+  static const _rowGap = 8.0;
+
+  /// The button row's height at [scale] (a capsule).
+  static double rowHeight(double scale) => MinimalStyle.button * scale + 2 * MinimalStyle.capsulePad;
+
+  /// Buttons and timeline at [scale].
+  static double bottomHeight(double scale) => rowHeight(scale) + _rowGap + MinimalTimeline.heightFor(scale);
+
+  /// The top bar's height.
+  static const topHeight = 72.0;
+
+  @override
+  Widget build(BuildContext context) {
+    const fade = ControlsFrame.fade;
+    Widget shown(Widget child, {Key? key}) => IgnorePointer(
+      key: key,
+      ignoring: !visible,
+      child: AnimatedOpacity(duration: fade, opacity: visible ? 1 : 0, child: child),
+    );
+    return Stack(
+      children: [
+        Positioned(
+          left: 0,
+          right: 0,
+          top: 0,
+          child: shown(
+            key: const ValueKey('minimal-top'),
+            DecoratedBox(
+              decoration: const BoxDecoration(
+                gradient: LinearGradient(
+                  begin: Alignment.topCenter,
+                  end: Alignment.bottomCenter,
+                  colors: [Color(0x99000000), Color(0x00000000)],
+                ),
+              ),
+              child: SizedBox(
+                height: topHeight + 24,
+                child: Padding(padding: const EdgeInsets.fromLTRB(16, 0, 10, 24), child: _top()),
+              ),
+            ),
+          ),
+        ),
+        Positioned(
+          left: 0,
+          right: 0,
+          bottom: 0,
+          child: Column(
+            mainAxisSize: MainAxisSize.min,
+            crossAxisAlignment: CrossAxisAlignment.stretch,
+            children: [
+              shown(
+                key: const ValueKey('minimal-buttons'),
+                Padding(
+                  padding: const EdgeInsets.fromLTRB(12, 0, 12, _rowGap),
+                  child: SizedBox(
+                    height: rowHeight(scale),
+                    child: SignalBuilder(
+                      builder: (context) {
+                        final s = model.snapshot.value;
+                        final layout = model.bar.value;
+                        // The clock lives on the timeline.
+                        List<Widget> cluster(List<BarControl> cs) => [
+                          for (final c in cs)
+                            if (c != BarControl.time) _control(context, c, s),
+                        ];
+                        return Row(
+                          children: [
+                            MinimalCapsule(scale: scale, children: cluster(layout.left)),
+                            const Spacer(),
+                            MinimalCapsule(scale: scale, children: cluster(layout.right)),
+                          ],
+                        );
+                      },
+                    ),
+                  ),
+                ),
+              ),
+              SignalBuilder(
+                builder: (context) {
+                  final line = AppSettings.instance.progressLine.value;
+                  return AnimatedOpacity(
+                    key: const ValueKey('minimal-timeline-wrap'),
+                    duration: fade,
+                    opacity: visible || line ? 1 : 0,
+                    child: MinimalTimeline(
+                      position: model.position.value,
+                      duration: model.duration.value,
+                      buffered: model.buffered.value,
+                      chapters: model.chapters.value,
+                      expanded: visible,
+                      remaining: model.settings.timeDisplay.value == TimeDisplay.remaining,
+                      scale: scale,
+                      onSeek: model.seek,
+                      onToggleTime: model.toggleTimeDisplay,
+                    ),
+                  );
+                },
+              ),
+            ],
+          ),
+        ),
+      ],
+    );
+  }
+
+  Widget _top() {
+    final m = model;
+    return Row(
+      children: [
+        const Expanded(
+          child: Align(alignment: AlignmentDirectional.centerStart, child: NowPlayingTitle()),
+        ),
+        UpNextButton(queue: m.queue, onPlayNextEpisode: m.playNextEpisode, look: UpNextLook.minimal, hold: hold),
+        const SizedBox(width: 4),
+        SignalBuilder(
+          builder: (context) {
+            final full = m.fullscreen.value;
+            return MinimalButton(
+              key: const ValueKey('minimal-collapse'),
+              icon: full ? Icons.fullscreen_exit_rounded : Icons.close_fullscreen_rounded,
+              tooltip: full ? 'Exit fullscreen (Esc)' : 'Back to the library (keeps playing)',
+              onPressed: full ? m.toggleFullscreen : m.collapse,
+            );
+          },
+        ),
+        ?windowButtons,
+      ],
+    );
+  }
+
+  Widget _control(BuildContext context, BarControl c, ControlsSnapshot s) {
+    final m = model;
+    final key = ValueKey('control-${c.name}');
+    final enabled = controlEnabled(c, s);
+    Widget button(VoidCallback? onPressed, {int? badge, bool accent = false}) => MinimalButton(
+      key: key,
+      icon: controlIcon(c, s),
+      tooltip: controlTooltip(c, s),
+      badge: badge,
+      accent: accent,
+      scale: scale,
+      onPressed: enabled ? onPressed : null,
+    );
+    switch (c) {
+      case BarControl.playPause:
+        return Padding(
+          padding: EdgeInsets.only(right: 4 * scale),
+          child: button(m.togglePlay, accent: true),
+        );
+      case BarControl.previous:
+        return button(m.previous);
+      case BarControl.next:
+        return button(m.next);
+      case BarControl.chapterPrevious:
+        return button(() => m.stepChapter(-1));
+      case BarControl.chapterNext:
+        return button(() => m.stepChapter(1));
+      case BarControl.volume:
+        return SignalBuilder(
+          key: key,
+          builder: (context) => VolumeControl(
+            volume: m.volume.value,
+            onChanged: m.setVolume,
+            onToggleMute: m.toggleMute,
+            sliderColor: Theme.of(context).colorScheme.primary,
+            trackColor: MinimalStyle.dim.withValues(alpha: 0.4),
+            button: (context, i, color, tip, onPressed) =>
+                MinimalButton(icon: i, tooltip: tip, color: color, scale: scale, onPressed: onPressed),
+          ),
+        );
+      case BarControl.time:
+        return const SizedBox.shrink();
+      case BarControl.subtitles || BarControl.audio:
+        final type = c == BarControl.audio ? JellyfinStreamType.audio : JellyfinStreamType.subtitle;
+        return SignalBuilder(
+          key: key,
+          builder: (context) => Builder(
+            builder: (context) => MinimalButton(
+              icon: controlIcon(c, s),
+              tooltip: controlTooltip(c, s),
+              badge: trackCount(m.tracks.value, type),
+              scale: scale,
+              onPressed: () => openTrackMenu(context, m, type),
+            ),
+          ),
+        );
+      case BarControl.settings:
+        return Builder(
+          key: key,
+          builder: (context) => MinimalButton(
+            icon: controlIcon(c, s),
+            tooltip: controlTooltip(c, s),
+            scale: scale,
+            onPressed: () => openControlsMenu(context, m),
+          ),
+        );
+      case BarControl.chat:
+        return SignalBuilder(
+          key: key,
+          builder: (context) => MinimalButton(
+            icon: controlIcon(c, s),
+            tooltip: controlTooltip(c, s),
+            badge: m.unread.value,
+            scale: scale,
+            onPressed: m.toggleChat,
+          ),
+        );
+      case BarControl.fullscreen:
+        return button(m.toggleFullscreen);
+    }
+  }
+}

apps/desktop/lib/src/controls/minimal/style.dart

@@ -0,0 +1,186 @@
+import 'package:flutter/material.dart';
+
+import '../../widgets/app_menu.dart' show AppMenuStyle;
+
+// The Minimal skin's look: the app's glass and accent (the theme's primary)
+// on a thick timeline band, with soft rounded buttons in two glass capsules.
+
+abstract final class MinimalStyle {
+  /// The timeline band (no blur: it spans the width over the picture).
+  static const band = Color(0xCC0E0E12);
+
+  /// The capsules holding the buttons: the player pills' glass.
+  static const capsule = AppMenuStyle.pillGlass;
+  static const hover = Color(0x1FFFFFFF);
+  static const text = Colors.white;
+  static const dim = Color(0xB3FFFFFF);
+  static const radius = 10.0;
+  static const fontSize = 13.0;
+
+  /// The tooltips and the timeline's hover tip.
+  static const tip = Color(0xEB18181C);
+
+  /// A button's box at scale 1.
+  static const button = 38.0;
+
+  /// The capsules' padding around the buttons.
+  static const capsulePad = 4.0;
+}
+
+/// The Minimal skin's tooltip: the app's dark glass colour, above.
+class MinimalTooltip extends StatelessWidget {
+  final String message;
+  final Widget child;
+  const MinimalTooltip({super.key, required this.message, required this.child});
+
+  @override
+  Widget build(BuildContext context) {
+    if (message.isEmpty) return child;
+    return Tooltip(
+      message: message,
+      preferBelow: false,
+      verticalOffset: 28,
+      waitDuration: const Duration(milliseconds: 300),
+      padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 5),
+      decoration: BoxDecoration(
+        color: MinimalStyle.tip,
+        borderRadius: BorderRadius.circular(8),
+        border: Border.all(color: AppMenuStyle.border, width: 0.5),
+      ),
+      textStyle: const TextStyle(color: MinimalStyle.text, fontSize: 12),
+      child: child,
+    );
+  }
+}
+
+/// A Minimal button: a white icon on a rounded square that lights on hover
+/// ([accent]: filled with the theme's primary, the play button), an
+/// optional [label] and a count [badge]. Never takes focus.
+class MinimalButton extends StatefulWidget {
+  final IconData icon;
+  final String tooltip;
+  final VoidCallback? onPressed;
+  final String? label;
+  final int? badge;
+  final bool accent;
+  final Color? color;
+  final double scale;
+  const MinimalButton({
+    super.key,
+    required this.icon,
+    required this.tooltip,
+    required this.onPressed,
+    this.label,
+    this.badge,
+    this.accent = false,
+    this.color,
+    this.scale = 1,
+  });
+
+  @override
+  State<MinimalButton> createState() => _MinimalButtonState();
+}
+
+class _MinimalButtonState extends State<MinimalButton> {
+  bool _hover = false;
+
+  @override
+  Widget build(BuildContext context) {
+    final w = widget;
+    final primary = Theme.of(context).colorScheme.primary;
+    final onPrimary = Theme.of(context).colorScheme.onPrimary;
+    final enabled = w.onPressed != null;
+    final size = MinimalStyle.button * w.scale;
+    final fg = !enabled
+        ? MinimalStyle.dim.withValues(alpha: 0.35)
+        : w.accent
+        ? onPrimary
+        : (w.color ?? MinimalStyle.text);
+    final bg = w.accent
+        ? (_hover ? Color.lerp(primary, Colors.white, 0.18)! : primary)
+        : (_hover && enabled ? MinimalStyle.hover : Colors.transparent);
+    final badge = w.badge;
+    return MinimalTooltip(
+      message: w.tooltip,
+      child: MouseRegion(
+        cursor: enabled ? SystemMouseCursors.click : SystemMouseCursors.basic,
+        onEnter: (_) => setState(() => _hover = true),
+        onExit: (_) => setState(() => _hover = false),
+        child: GestureDetector(
+          behavior: HitTestBehavior.opaque,
+          onTap: w.onPressed,
+          child: AnimatedContainer(
+            duration: const Duration(milliseconds: 120),
+            height: size,
+            constraints: BoxConstraints(minWidth: size),
+            padding: EdgeInsets.symmetric(horizontal: w.label == null ? 0 : 10 * w.scale),
+            decoration: BoxDecoration(
+              color: bg,
+              borderRadius: BorderRadius.circular(w.accent ? size / 2 : MinimalStyle.radius * w.scale),
+            ),
+            child: Row(
+              mainAxisSize: MainAxisSize.min,
+              mainAxisAlignment: MainAxisAlignment.center,
+              children: [
+                Stack(
+                  clipBehavior: Clip.none,
+                  children: [
+                    Icon(w.icon, color: fg, size: (w.accent ? 26 : 22) * w.scale),
+                    if (badge != null && badge > 0)
+                      Positioned(
+                        right: -7,
+                        top: -5,
+                        child: Container(
+                          key: const ValueKey('minimal-badge'),
+                          padding: const EdgeInsets.symmetric(horizontal: 4),
+                          decoration: BoxDecoration(color: primary, borderRadius: BorderRadius.circular(999)),
+                          child: Text(
+                            '$badge',
+                            style: TextStyle(color: onPrimary, fontSize: 9, height: 1.35, fontWeight: FontWeight.w700),
+                          ),
+                        ),
+                      ),
+                  ],
+                ),
+                if (w.label != null) ...[
+                  SizedBox(width: 6 * w.scale),
+                  Text(
+                    w.label!,
+                    style: TextStyle(
+                      color: fg,
+                      fontSize: MinimalStyle.fontSize * w.scale,
+                      fontFeatures: const [FontFeature.tabularFigures()],
+                    ),
+                  ),
+                ],
+              ],
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+/// A glass capsule around a row of Minimal buttons.
+class MinimalCapsule extends StatelessWidget {
+  final List<Widget> children;
+  final double scale;
+  const MinimalCapsule({super.key, required this.children, this.scale = 1});
+
+  @override
+  Widget build(BuildContext context) {
+    final r = BorderRadius.circular(MinimalStyle.radius * scale + MinimalStyle.capsulePad);
+    return DecoratedBox(
+      decoration: BoxDecoration(
+        color: MinimalStyle.capsule,
+        borderRadius: r,
+        border: Border.all(color: AppMenuStyle.border, width: 0.5),
+      ),
+      child: Padding(
+        padding: const EdgeInsets.all(MinimalStyle.capsulePad),
+        child: Row(mainAxisSize: MainAxisSize.min, spacing: 2, children: children),
+      ),
+    );
+  }
+}

apps/desktop/lib/src/controls/minimal/timeline.dart

@@ -0,0 +1,578 @@
+import 'dart:async';
+import 'dart:math' as math;
+
+import 'package:flutter/material.dart';
+
+import '../../playback/media_marks.dart';
+import '../frame.dart';
+import 'style.dart';
+
+// The Minimal skin's timeline: a band across the bottom with the played
+// part tinted in the accent and the position as a line, the part not
+// downloaded yet striped, chapter starts as dots on the top edge (click one
+// to jump), the elapsed time left and the total or the time left right,
+// the buffered seconds by the position while under a minute, and a tip
+// with the time (and the chapter title) under the mouse. Hidden, it shrinks
+// to a thin progress line.
+//
+// Inspired by the timeline of uosc (github.com/tomasklaen/uosc, LGPL-2.1,
+// by tomasklaen): the striped unbuffered part, the remaining time and the
+// thin line when hidden come from there. The drawing, geometry and values
+// here are our own.
+
+/// Sizes at scale 1.
+abstract final class MinimalTimelineSpec {
+  /// The band's height while the controls are up.
+  static const size = 36.0;
+
+  /// What is left of it while they are hidden.
+  static const lineSize = 3.0;
+
+  /// The position line.
+  static const lineWidth = 2.0;
+  static const fontSize = 15.0;
+
+  /// The times' inset from the ends.
+  static const inset = 12.0;
+
+  /// A chapter dot's radius (doubled-ish while hovered).
+  static const dot = 3.5;
+
+  /// The cache label shows while less than this is buffered ahead.
+  static const bufferedThreshold = Duration(seconds: 60);
+
+  /// Collapse / grow.
+  static const animation = Duration(milliseconds: 120);
+}
+
+/// Fraction of [total] at [d], 0..1 (0 without a duration).
+double timelineFraction(Duration d, Duration total) {
+  final t = total.inMicroseconds;
+  if (t <= 0) return 0;
+  return (d.inMicroseconds / t).clamp(0.0, 1.0);
+}
+
+/// Where the part not downloaded yet starts (it runs to the end), as a
+/// fraction; null when nothing known is missing. We know only the end of
+/// mpv's cache ahead ([buffered]); a cache within half a second of the end
+/// leaves nothing.
+double? uncachedFrom({required Duration position, required Duration buffered, required Duration duration}) {
+  if (duration <= Duration.zero || buffered <= Duration.zero) return null;
+  final from = buffered > position ? buffered : position;
+  if (duration - from <= const Duration(milliseconds: 500)) return null;
+  return timelineFraction(from, duration);
+}
+
+/// The cache label by the position ("12s"): the seconds buffered ahead,
+/// while under [MinimalTimelineSpec.bufferedThreshold] and the cache does
+/// not reach the end.
+String? cacheLabel({required Duration position, required Duration buffered, required Duration duration}) {
+  if (duration <= Duration.zero || buffered <= Duration.zero) return null;
+  if (duration - buffered <= const Duration(milliseconds: 500)) return null;
+  final ahead = buffered > position ? buffered - position : Duration.zero;
+  if (ahead >= MinimalTimelineSpec.bufferedThreshold) return null;
+  return '${(ahead.inMilliseconds / 1000).round()}s';
+}
+
+/// The band's height while it animates between hidden (0) and shown (1).
+double minimalBandSize(double visibility, double scale) =>
+    MinimalTimelineSpec.lineSize +
+    ((MinimalTimelineSpec.size * scale - MinimalTimelineSpec.lineSize) * visibility).roundToDouble();
+
+/// The Minimal timeline. [expanded] false (the controls hidden) shrinks it,
+/// animated, to the progress line. Seeks ([onSeek]) on press, on every drag
+/// move and on release; a press on a hovered chapter dot jumps to that
+/// chapter, one on the right-hand time switches it ([onToggleTime]).
+class MinimalTimeline extends StatefulWidget {
+  final Duration position;
+  final Duration duration;
+
+  /// End of the cached range.
+  final Duration buffered;
+  final List<MediaChapter> chapters;
+  final bool expanded;
+
+  /// The right-hand time: the time left instead of the total.
+  final bool remaining;
+  final double scale;
+  final ValueChanged<Duration> onSeek;
+  final VoidCallback? onToggleTime;
+  const MinimalTimeline({
+    super.key,
+    required this.position,
+    required this.duration,
+    this.buffered = Duration.zero,
+    this.chapters = const [],
+    this.expanded = true,
+    this.remaining = true,
+    this.scale = 1,
+    required this.onSeek,
+    this.onToggleTime,
+  });
+
+  static double heightFor(double scale) => MinimalTimelineSpec.size * scale;
+  static const collapsedHeight = MinimalTimelineSpec.lineSize;
+
+  @override
+  State<MinimalTimeline> createState() => _MinimalTimelineState();
+}
+
+class _MinimalTimelineState extends State<MinimalTimeline> {
+  Offset? _hover;
+  bool _dragging = false;
+  double _dragFraction = 0;
+  Duration? _lastSent;
+  // A released seek, shown until the position catches up (else the line
+  // jumps back to the old position for a moment).
+  double? _pending;
+  Timer? _pendingTimer;
+
+  double get _scale => widget.scale;
+  Duration _at(double fraction) => widget.duration * fraction.clamp(0.0, 1.0);
+
+  void _send(Duration d) {
+    if (d == _lastSent) return;
+    _lastSent = d;
+    widget.onSeek(d);
+  }
+
+  void _drag(bool on) {
+    if (_dragging == on) return;
+    setState(() => _dragging = on);
+    ControlsFrame.maybeOf(context)?.hold(on);
+  }
+
+  void _settle(double fraction) {
+    _pending = fraction;
+    _pendingTimer?.cancel();
+    _pendingTimer = Timer(const Duration(seconds: 2), () {
+      if (mounted) setState(() => _pending = null);
+    });
+  }
+
+  @override
+  void didUpdateWidget(MinimalTimeline old) {
+    super.didUpdateWidget(old);
+    if (!widget.expanded && old.expanded) _hover = null;
+    final p = _pending;
+    if (p != null && widget.duration > Duration.zero) {
+      final off = (widget.position - _at(p)).abs();
+      if (off < const Duration(milliseconds: 1500)) {
+        _pending = null;
+        _pendingTimer?.cancel();
+      }
+    }
+  }
+
+  @override
+  void dispose() {
+    _pendingTimer?.cancel();
+    // A drag cut short by a rebuild must not keep the controls up.
+    if (_dragging) ControlsFrame.maybeOf(context)?.hold(false);
+    super.dispose();
+  }
+
+  double _dotRadius(bool hovered) => MinimalTimelineSpec.dot * _scale * (hovered ? 1.7 : 1);
+
+  /// The chapter whose dot is within reach of [at].
+  int? _hoveredChapter(double width, List<MediaChapter> marks, Offset? at) {
+    if (at == null || _dragging) return null;
+    final reach = _dotRadius(false) * 2.5;
+    int? best;
+    var bestD = double.infinity;
+    for (var i = 0; i < marks.length; i++) {
+      final cx = width * timelineFraction(marks[i].start, widget.duration);
+      final d = (Offset(cx, 0) - at).distance;
+      if (d <= reach && d < bestD) {
+        best = i;
+        bestD = d;
+      }
+    }
+    return best;
+  }
+
+  String? _rightText(Duration shown) {
+    final d = widget.duration;
+    if (d <= Duration.zero) return null;
+    if (!widget.remaining) return formatClock(d);
+    final left = d - shown;
+    return '-${formatClock(left.isNegative ? Duration.zero : left)}';
+  }
+
+  // The painter's text takes the app's font (a TextPainter does not
+  // inherit it).
+  String? _font;
+
+  TextStyle get _timeStyle => TextStyle(
+    fontFamily: _font,
+    color: MinimalStyle.text,
+    fontSize: MinimalTimelineSpec.fontSize * _scale,
+    height: 1,
+    fontWeight: FontWeight.w500,
+    fontFeatures: const [FontFeature.tabularFigures()],
+  );
+
+  /// Where the right-hand time sits (a press there switches it).
+  bool _onRightTime(Offset at, double width, String? text) {
+    if (text == null || widget.onToggleTime == null) return false;
+    final tp = TextPainter(
+      text: TextSpan(text: text, style: _timeStyle),
+      textDirection: TextDirection.ltr,
+    )..layout();
+    return at.dx >= width - MinimalTimelineSpec.inset * _scale - tp.width - 6;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    _font = DefaultTextStyle.of(context).style.fontFamily ?? Theme.of(context).textTheme.bodyMedium?.fontFamily;
+    return LayoutBuilder(
+      builder: (context, constraints) => TweenAnimationBuilder<double>(
+        tween: Tween(end: widget.expanded ? 1 : 0),
+        duration: MinimalTimelineSpec.animation,
+        builder: (context, visibility, _) => _band(context, constraints.maxWidth, visibility),
+      ),
+    );
+  }
+
+  Widget _band(BuildContext context, double width, double visibility) {
+    final expanded = widget.expanded;
+    final duration = widget.duration;
+    final size = minimalBandSize(visibility, _scale);
+    final progress = _dragging ? _dragFraction : (_pending ?? timelineFraction(widget.position, duration));
+    final shown = _at(progress);
+    final marks = duration > Duration.zero ? widget.chapters : const <MediaChapter>[];
+    final hover = expanded ? _hover : null;
+    final hovered = _hoveredChapter(width, marks, hover);
+    final hoverFraction = hovered != null
+        ? timelineFraction(marks[hovered].start, duration)
+        : (hover == null || duration <= Duration.zero || width <= 0 ? null : (hover.dx / width).clamp(0.0, 1.0));
+    final hoverAt = hoverFraction == null ? null : _at(hoverFraction);
+    final cursorX = hoverFraction == null ? null : width * hoverFraction;
+    final hoverChapter = hoverAt == null ? null : chapterIndexAt(widget.chapters, hoverAt);
+    final hoverTitle = hoverChapter == null ? '' : widget.chapters[hoverChapter].title;
+    // Text fades out before it would overflow the shrinking band.
+    final minText = MinimalTimelineSpec.fontSize * _scale;
+    final textOpacity = ((size - minText) / (minText / 2)).clamp(0.0, 1.0);
+    final right = _rightText(shown);
+    final primary = Theme.of(context).colorScheme.primary;
+    final painter = MinimalTimelinePainter(
+      progress: progress,
+      visibility: visibility,
+      accent: primary,
+      scale: _scale,
+      uncached: uncachedFrom(position: widget.position, buffered: widget.buffered, duration: duration),
+      chapters: [for (final c in marks) timelineFraction(c.start, duration)],
+      hoveredChapter: hovered,
+      hoverX: hovered == null ? cursorX : null,
+      textOpacity: textOpacity,
+      elapsed: duration > Duration.zero ? formatClock(shown) : null,
+      right: right,
+      cache: cacheLabel(position: widget.position, buffered: widget.buffered, duration: duration),
+      timeStyle: _timeStyle,
+    );
+    final bar = SizedBox(
+      key: const ValueKey('minimal-timeline'),
+      width: width,
+      height: size,
+      child: Stack(
+        clipBehavior: Clip.none,
+        children: [
+          Positioned.fill(
+            child: RepaintBoundary(child: CustomPaint(painter: painter)),
+          ),
+          if (hoverAt != null && cursorX != null)
+            Positioned(
+              left: 0,
+              right: 0,
+              bottom: size + 8,
+              height: 120,
+              child: IgnorePointer(
+                child: CustomMultiChildLayout(
+                  delegate: _TipLayout(x: cursorX),
+                  children: [
+                    LayoutId(
+                      id: #tip,
+                      child: _HoverTip(time: formatClock(hoverAt), chapter: hoverTitle, scale: _scale),
+                    ),
+                  ],
+                ),
+              ),
+            ),
+        ],
+      ),
+    );
+    if (!expanded) return IgnorePointer(child: bar);
+    Offset clampTo(Offset p) => Offset(p.dx.clamp(0.0, width), p.dy);
+    return MouseRegion(
+      cursor: SystemMouseCursors.click,
+      onEnter: (e) => setState(() => _hover = clampTo(e.localPosition)),
+      onHover: (e) => setState(() => _hover = clampTo(e.localPosition)),
+      onExit: (_) {
+        if (!_dragging) setState(() => _hover = null);
+      },
+      child: Listener(
+        behavior: HitTestBehavior.opaque,
+        onPointerDown: (e) {
+          if (width <= 0) return;
+          final at = clampTo(e.localPosition);
+          if (_onRightTime(at, width, right)) {
+            widget.onToggleTime?.call();
+            return;
+          }
+          if (duration <= Duration.zero) return;
+          final chapter = _hoveredChapter(width, marks, at);
+          _lastSent = null;
+          if (chapter != null) {
+            _settle(timelineFraction(marks[chapter].start, duration));
+            _send(marks[chapter].start);
+            setState(() {});
+            return;
+          }
+          _pending = null;
+          _dragFraction = (at.dx / width).clamp(0.0, 1.0);
+          _drag(true);
+          _send(_at(_dragFraction));
+        },
+        onPointerMove: (e) {
+          if (!_dragging) return;
+          final at = clampTo(e.localPosition);
+          setState(() {
+            _hover = at;
+            _dragFraction = (at.dx / width).clamp(0.0, 1.0);
+          });
+          _send(_at(_dragFraction));
+        },
+        onPointerUp: (e) {
+          if (!_dragging) return;
+          _send(_at(_dragFraction));
+          _settle(_dragFraction);
+          final p = e.localPosition;
+          if (p.dx < 0 || p.dx > width || p.dy < 0 || p.dy > size) _hover = null;
+          _drag(false);
+        },
+        onPointerCancel: (_) => _drag(false),
+        child: bar,
+      ),
+    );
+  }
+}
+
+class _HoverTip extends StatelessWidget {
+  final String time;
+  final String chapter;
+  final double scale;
+  const _HoverTip({required this.time, required this.chapter, required this.scale});
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      constraints: const BoxConstraints(maxWidth: 360),
+      padding: EdgeInsets.symmetric(horizontal: 10 * scale, vertical: 5 * scale),
+      decoration: BoxDecoration(
+        color: MinimalStyle.tip,
+        borderRadius: BorderRadius.circular(8),
+        border: Border.all(color: const Color(0x1FFFFFFF), width: 0.5),
+      ),
+      child: Column(
+        mainAxisSize: MainAxisSize.min,
+        children: [
+          if (chapter.isNotEmpty)
+            Text(
+              chapter,
+              key: const ValueKey('minimal-hover-chapter'),
+              maxLines: 1,
+              overflow: TextOverflow.ellipsis,
+              style: TextStyle(color: MinimalStyle.text, fontSize: 13 * scale, fontWeight: FontWeight.w600),
+            ),
+          Text(
+            time,
+            key: const ValueKey('minimal-hover-time'),
+            style: TextStyle(
+              color: chapter.isEmpty ? MinimalStyle.text : MinimalStyle.dim,
+              fontSize: 13 * scale,
+              fontFeatures: const [FontFeature.tabularFigures()],
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+/// The hover tip centred on [x], kept inside the band's ends.
+class _TipLayout extends MultiChildLayoutDelegate {
+  final double x;
+  _TipLayout({required this.x});
+
+  @override
+  void performLayout(Size size) {
+    const gap = 4.0;
+    final tip = layoutChild(#tip, BoxConstraints.loose(size));
+    final left = (x - tip.width / 2).clamp(gap, math.max(gap, size.width - gap - tip.width)).toDouble();
+    positionChild(#tip, Offset(left, size.height - tip.height));
+  }
+
+  @override
+  bool shouldRelayout(_TipLayout old) => old.x != x;
+}
+
+/// Paints the band: background, the played tint and the (white) position
+/// line, the stripes over the part not downloaded, chapter marks, the
+/// times, the hover line.
+class MinimalTimelinePainter extends CustomPainter {
+  /// The playing position, 0..1.
+  final double progress;
+
+  /// 0 hidden .. 1 shown.
+  final double visibility;
+  final Color accent;
+  final double scale;
+
+  /// Start of the part not downloaded (to the end), as a fraction.
+  final double? uncached;
+
+  /// Chapter starts, as fractions.
+  final List<double> chapters;
+  final int? hoveredChapter;
+  final double? hoverX;
+  final double textOpacity;
+  final String? elapsed;
+  final String? right;
+  final String? cache;
+  final TextStyle timeStyle;
+  const MinimalTimelinePainter({
+    required this.progress,
+    this.visibility = 1,
+    this.accent = Colors.white,
+    this.scale = 1,
+    this.uncached,
+    this.chapters = const [],
+    this.hoveredChapter,
+    this.hoverX,
+    this.textOpacity = 1,
+    this.elapsed,
+    this.right,
+    this.cache,
+    this.timeStyle = const TextStyle(fontSize: MinimalTimelineSpec.fontSize),
+  });
+
+  /// x of the position line's centre.
+  double lineX(double width) {
+    final lw = MinimalTimelineSpec.lineWidth * scale;
+    return (width * progress).clamp(lw / 2, math.max(lw / 2, width - lw / 2));
+  }
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    final w = size.width, h = size.height;
+    final x = lineX(w);
+    final band = Offset.zero & size;
+    // The band, darker as it grows; hidden, a faint track.
+    canvas.drawRect(band, Paint()..color = Color.lerp(const Color(0x40FFFFFF), MinimalStyle.band, visibility)!);
+    // Played: an accent tint, solid once the band is a line.
+    canvas.drawRect(
+      Rect.fromLTRB(0, 0, x, h),
+      Paint()..color = accent.withValues(alpha: 0.28 + 0.72 * (1 - visibility)),
+    );
+    _stripes(canvas, w, h);
+    _chapters(canvas, w, h);
+    if (visibility > 0) {
+      final lw = MinimalTimelineSpec.lineWidth * scale;
+      canvas.drawRect(
+        Rect.fromLTRB(x - lw / 2, 0, x + lw / 2, h),
+        Paint()..color = Colors.white.withValues(alpha: visibility),
+      );
+    }
+    if (textOpacity > 0) _times(canvas, w, h, x);
+    final hx = hoverX;
+    if (hx != null) {
+      canvas.drawRect(Rect.fromLTRB(hx - 0.5, 0, hx + 0.5, h), Paint()..color = Colors.white.withValues(alpha: 0.45));
+    }
+  }
+
+  /// Thin 45° stripes over the part not downloaded yet.
+  void _stripes(Canvas canvas, double w, double h) {
+    final from = uncached;
+    if (from == null) return;
+    final ax = (w * from).floorToDouble();
+    if (ax >= w) return;
+    final period = 7.0 * scale;
+    canvas.save();
+    canvas.clipRect(Rect.fromLTRB(ax, 0, w, h));
+    final paint = Paint()
+      ..color = Colors.white.withValues(alpha: 0.10 + 0.08 * (1 - visibility))
+      ..strokeWidth = 1.5 * scale;
+    for (var c = (ax / period).floorToDouble() * period - h; c <= w; c += period) {
+      canvas.drawLine(Offset(c, h), Offset(c + h, 0), paint);
+    }
+    canvas.restore();
+  }
+
+  void _chapters(Canvas canvas, double w, double h) {
+    final cut = Paint()..color = Colors.black.withValues(alpha: 0.55);
+    for (final f in chapters) {
+      if (f <= 0) continue;
+      final cx = w * f;
+      canvas.drawRect(Rect.fromLTRB(cx - 0.5, 0, cx + 0.5, h), cut);
+    }
+    if (visibility <= 0) return;
+    final r = MinimalTimelineSpec.dot * scale * visibility;
+    void dot(double f, double radius, Color fill) {
+      final c = Offset(w * f, 0);
+      canvas.drawCircle(c, radius + 1, Paint()..color = Colors.black.withValues(alpha: 0.7));
+      canvas.drawCircle(c, radius, Paint()..color = fill);
+    }
+
+    // Not at 0: the band's start says that already.
+    for (var i = 0; i < chapters.length; i++) {
+      if (i != hoveredChapter && chapters[i] > 0) dot(chapters[i], r, Colors.white.withValues(alpha: 0.9));
+    }
+    final hv = hoveredChapter;
+    if (hv != null && hv < chapters.length) dot(chapters[hv], r * 1.7, accent);
+  }
+
+  TextPainter _text(String s, TextStyle style) => TextPainter(
+    text: TextSpan(text: s, style: style),
+    textDirection: TextDirection.ltr,
+  )..layout();
+
+  /// White text with a soft shadow, so it reads over the accent tint too.
+  void _label(Canvas canvas, String s, TextStyle style, Offset at) {
+    final o = textOpacity;
+    _text(
+      s,
+      style.copyWith(
+        color: (style.color ?? Colors.white).withValues(alpha: o),
+        shadows: [Shadow(color: Colors.black.withValues(alpha: 0.8 * o), blurRadius: 3)],
+      ),
+    ).paint(canvas, at);
+  }
+
+  void _times(Canvas canvas, double w, double h, double lineX) {
+    final inset = MinimalTimelineSpec.inset * scale;
+    final fs = timeStyle.fontSize ?? MinimalTimelineSpec.fontSize;
+    final cy = h / 2;
+    final e = elapsed, r = right;
+    final ew = e == null ? 0.0 : _text(e, timeStyle).width;
+    final rw = r == null ? 0.0 : _text(r, timeStyle).width;
+    final c = cache;
+    if (c != null) {
+      final cs = timeStyle.copyWith(fontSize: fs * 0.8, color: MinimalStyle.dim);
+      final cw = _text(c, cs).width;
+      const margin = 6.0;
+      var x = lineX + margin;
+      final minX = inset + margin + ew, maxX = w - inset - margin - rw;
+      if (x < minX) {
+        x = minX;
+      } else if (x + cw > maxX) {
+        x = maxX - cw;
+      }
+      _label(canvas, c, cs, Offset(x, cy - fs * 0.4));
+    }
+    if (e != null) _label(canvas, e, timeStyle, Offset(inset, cy - fs / 2));
+    if (r != null) _label(canvas, r, timeStyle, Offset(w - inset - rw, cy - fs / 2));
+  }
+
+  @override
+  bool shouldRepaint(MinimalTimelinePainter old) => true;
+}

apps/desktop/lib/src/controls/model/controls_layout.dart

@@ -0,0 +1,235 @@
+import 'package:flutter/material.dart' show IconData, Icons;
+
+import '../../playback/media_marks.dart' show formatClock;
+import 'controls_prefs.dart';
+
+// The controls layout, defined once for both skins: which controls the
+// bottom bar has, in which order, which actions sit in the ⚙ menu instead,
+// and their icons, tooltips and labels. Pure: everything here is a
+// function of a [ControlsSnapshot] and the user's choices, so tests cover
+// it without a player.
+
+/// What playback does as this viewer sees it. In a server "play" is being
+/// ready: the video plays once everyone is.
+enum PlayState {
+  /// The video plays (the button pauses: you go unready).
+  playing,
+
+  /// You are ready; the others are not yet (the button unreadies you).
+  waiting,
+
+  /// You are not ready (the button readies you).
+  paused,
+
+  /// The media ended.
+  finished,
+}
+
+/// A control in the bottom bar.
+enum BarControl {
+  playPause,
+
+  /// Previous episode.
+  previous,
+
+  /// Up next's first item, else the next episode.
+  next,
+  chapterPrevious,
+  chapterNext,
+  volume,
+  time,
+  subtitles,
+  audio,
+
+  /// ⚙: everything that is not a bar button.
+  settings,
+  chat,
+  fullscreen,
+}
+
+/// An action in the ⚙ menu.
+enum ControlAction {
+  chapters('Chapters…', null),
+  subtitles('Subtitles…', null),
+  audio('Audio…', null),
+  skipForward('Skip 1:30', 'Shift+Right'),
+  shaders('Upscaling shader…', 'Ctrl+0…6'),
+  chat('Chat & activity', 'Tab'),
+  changeVideo('Change video', null),
+  copyLink('Copy link', null),
+  reload('Reload video', 'Ctrl+R'),
+  markAllReady('Mark everyone ready', null),
+  markProblem('Mark a problem', 'Ctrl+Shift+B'),
+  playerSettings('Player settings…', null),
+  leave('Leave server', null);
+
+  final String label;
+  final String? hint;
+  const ControlAction(this.label, this.hint);
+}
+
+/// The bar's order, left cluster then right cluster. The play button is
+/// always first and fullscreen always last; controls that do not apply
+/// (no episode, no chapters) or that the user hid are left out, the rest
+/// keep their order.
+abstract final class ControlsLayout {
+  static const left = [
+    BarControl.playPause,
+    BarControl.previous,
+    BarControl.next,
+    BarControl.chapterPrevious,
+    BarControl.chapterNext,
+    BarControl.volume,
+    BarControl.time,
+  ];
+  static const right = [
+    BarControl.subtitles,
+    BarControl.audio,
+    BarControl.settings,
+    BarControl.chat,
+    BarControl.fullscreen,
+  ];
+
+  /// The ⚙ menu's order.
+  static const menu = ControlAction.values;
+}
+
+/// What the layout depends on, at one moment.
+class ControlsSnapshot {
+  final PlayState play;
+
+  /// The previous episode's label; null: none.
+  final String? previousLabel;
+
+  /// Up next's first item's title, else the next episode's label; null:
+  /// nothing next.
+  final String? nextLabel;
+
+  /// [nextLabel] is Up next (not an episode).
+  final bool nextIsUpNext;
+  final bool hasChapters;
+
+  /// The media's length is known (seeks and skips make sense).
+  final bool hasDuration;
+
+  /// Watching alone (no one to mark ready).
+  final bool solo;
+
+  /// A link to copy (`SessionCoordinator.currentLink`).
+  final bool hasLink;
+  final bool fullscreen;
+  final bool chatOpen;
+  const ControlsSnapshot({
+    this.play = PlayState.paused,
+    this.previousLabel,
+    this.nextLabel,
+    this.nextIsUpNext = false,
+    this.hasChapters = false,
+    this.hasDuration = false,
+    this.solo = false,
+    this.hasLink = false,
+    this.fullscreen = false,
+    this.chatOpen = false,
+  });
+}
+
+/// The bar's two clusters for [s], in [ControlsLayout] order.
+({List<BarControl> left, List<BarControl> right}) barControls(ControlsSnapshot s, Set<OptionalControl> hidden) {
+  bool on(BarControl c) => switch (c) {
+    BarControl.previous => s.previousLabel != null,
+    BarControl.next => s.nextLabel != null,
+    BarControl.chapterPrevious || BarControl.chapterNext => s.hasChapters && !hidden.contains(OptionalControl.chapters),
+    BarControl.subtitles => !hidden.contains(OptionalControl.subtitles),
+    BarControl.audio => !hidden.contains(OptionalControl.audio),
+    BarControl.chat => !hidden.contains(OptionalControl.chat),
+    _ => true,
+  };
+  return (
+    left: [
+      for (final c in ControlsLayout.left)
+        if (on(c)) c,
+    ],
+    right: [
+      for (final c in ControlsLayout.right)
+        if (on(c)) c,
+    ],
+  );
+}
+
+/// The ⚙ menu for [s]: every action that applies, minus those the bar
+/// already shows.
+List<ControlAction> menuActions(ControlsSnapshot s, Set<OptionalControl> hidden) => [
+  for (final a in ControlsLayout.menu)
+    if (switch (a) {
+      ControlAction.chapters => s.hasChapters,
+      ControlAction.subtitles => hidden.contains(OptionalControl.subtitles),
+      ControlAction.audio => hidden.contains(OptionalControl.audio),
+      ControlAction.skipForward => s.hasDuration,
+      ControlAction.chat => hidden.contains(OptionalControl.chat),
+      ControlAction.copyLink => s.hasLink,
+      ControlAction.markAllReady => !s.solo,
+      _ => true,
+    })
+      a,
+];
+
+/// Whether a bar control does something now (a skin dims it otherwise).
+bool controlEnabled(BarControl c, ControlsSnapshot s) => switch (c) {
+  BarControl.chapterPrevious || BarControl.chapterNext => s.hasChapters && s.hasDuration,
+  BarControl.previous => s.previousLabel != null,
+  BarControl.next => s.nextLabel != null,
+  _ => true,
+};
+
+/// The icon of a bar control (volume and the clock draw their own).
+IconData controlIcon(BarControl c, ControlsSnapshot s) => switch (c) {
+  BarControl.playPause => switch (s.play) {
+    PlayState.playing => Icons.pause_rounded,
+    // Ready: the check says so; a click unreadies.
+    PlayState.waiting => Icons.check_rounded,
+    PlayState.finished => Icons.replay_rounded,
+    PlayState.paused => Icons.play_arrow_rounded,
+  },
+  BarControl.previous => Icons.skip_previous_rounded,
+  BarControl.next => Icons.skip_next_rounded,
+  BarControl.chapterPrevious => Icons.chevron_left_rounded,
+  BarControl.chapterNext => Icons.chevron_right_rounded,
+  BarControl.volume => Icons.volume_up_rounded,
+  BarControl.time => Icons.schedule_rounded,
+  BarControl.subtitles => Icons.subtitles_outlined,
+  BarControl.audio => Icons.graphic_eq_rounded,
+  BarControl.settings => Icons.settings_outlined,
+  BarControl.chat => s.chatOpen ? Icons.chat_bubble_rounded : Icons.chat_bubble_outline_rounded,
+  BarControl.fullscreen => s.fullscreen ? Icons.fullscreen_exit_rounded : Icons.fullscreen_rounded,
+};
+
+/// The tooltip of a bar control, with its key.
+String controlTooltip(BarControl c, ControlsSnapshot s) => switch (c) {
+  BarControl.playPause => switch (s.play) {
+    PlayState.playing => 'Pause for everyone (Space)',
+    PlayState.waiting => 'Ready, waiting for the others (Space: not ready)',
+    PlayState.paused => s.solo ? 'Play (Space)' : 'Ready: play when everyone is (Space)',
+    PlayState.finished => 'Ready (Space)',
+  },
+  BarControl.previous => 'Previous: ${s.previousLabel ?? ''}  (< or Shift+P)',
+  BarControl.next => '${s.nextIsUpNext ? 'Up next' : 'Next'}: ${s.nextLabel ?? ''}  (> or Shift+N)',
+  BarControl.chapterPrevious => 'Previous chapter (PgUp)',
+  BarControl.chapterNext => 'Next chapter (PgDn)',
+  BarControl.volume => 'Volume (scroll, ↑ / ↓)',
+  BarControl.time => 'Elapsed / remaining (click to switch)',
+  BarControl.subtitles => 'Subtitles',
+  BarControl.audio => 'Audio',
+  BarControl.settings => 'Settings and more',
+  BarControl.chat => 'Chat & activity (Tab)',
+  BarControl.fullscreen => s.fullscreen ? 'Exit fullscreen (F, Esc)' : 'Fullscreen (F)',
+};
+
+/// The bar's clock: "6:00 / 24:00", or the time left ("-18:00"); "0:00"
+/// parts while the length is unknown.
+String clockText(Duration position, Duration duration, TimeDisplay display) {
+  if (display == TimeDisplay.remaining && duration > Duration.zero) {
+    final left = duration - position;
+    return '-${formatClock(left.isNegative ? Duration.zero : left)}';
+  }
+  return '${formatClock(position)} / ${formatClock(duration)}';
+}

apps/desktop/lib/src/controls/model/controls_model.dart

@@ -0,0 +1,214 @@
+import 'package:flutter/foundation.dart';
+import 'package:signals/signals_flutter.dart';
+
+import '../../jellyfin/track_prefs.dart' show MpvTrack;
+import '../../playback/media_marks.dart';
+import '../../playback/playback_controller.dart';
+import '../../queue/queue_controller.dart';
+import '../../session/session_coordinator.dart';
+import '../../shaders/shader_presets.dart';
+import '../../state/session_state.dart';
+import '../../state/settings.dart';
+import '../player_settings.dart' show applyShaderChoice;
+import '../volume.dart' as vol;
+import 'controls_layout.dart';
+
+/// A track pick from a track menu: audio id, subtitle id, or off.
+typedef TrackPick = ({int? aid, int? sid, bool subtitlesOff});
+
+/// The player controls, independent of how they look: what the controls
+/// show (state, as signals) and what they do (actions), wired to the
+/// session once. Both skins only draw this and call its actions, so a
+/// control added here shows in both. Built by the session player per
+/// mount; [fullscreen], [chatOpen] and [unread] are the shell's, passed in.
+class PlayerControlsModel {
+  final SessionCoordinator coord;
+  final ReadonlySignal<bool> fullscreen;
+  final ReadonlySignal<bool> chatOpen;
+  final ReadonlySignal<int> unread;
+  final VoidCallback _toggleFullscreen;
+  final VoidCallback _toggleChat;
+  final VoidCallback _changeVideo;
+  final VoidCallback _collapse;
+  final VoidCallback _leave;
+
+  PlayerControlsModel({
+    required this.coord,
+    required this.fullscreen,
+    required this.chatOpen,
+    required this.unread,
+    required VoidCallback onToggleFullscreen,
+    required VoidCallback onToggleChat,
+    required VoidCallback onChangeVideo,
+    required VoidCallback onCollapse,
+    required VoidCallback onLeave,
+  }) : _toggleFullscreen = onToggleFullscreen,
+       _toggleChat = onToggleChat,
+       _changeVideo = onChangeVideo,
+       _collapse = onCollapse,
+       _leave = onLeave;
+
+  PlaybackController get playback => coord.playback;
+  QueueController get queue => coord.queue;
+  AppSettings get settings => AppSettings.instance;
+
+  // ---------------------------------------------------------------- state
+
+  ReadonlySignal<Duration> get position => playback.position;
+  ReadonlySignal<Duration> get duration => playback.duration;
+
+  /// End of the cached range ahead of the position.
+  ReadonlySignal<Duration> get buffered => playback.buffered;
+  ReadonlySignal<List<MediaChapter>> get chapters => playback.chapters;
+  ReadonlySignal<int?> get currentChapter => playback.currentChapter;
+  ReadonlySignal<List<MpvTrack>> get tracks => playback.tracks;
+
+  /// 0..`maxVolume`.
+  ReadonlySignal<double> get volume => playback.volume;
+  ReadonlySignal<SkipOffer?> get skipOffer => coord.skipOffer;
+  ReadonlySignal<RenderMode> get renderMode => playback.renderMode;
+
+  /// Play / pause as the session sees it ([PlayState]).
+  late final Computed<PlayState> play = computed(() {
+    final r = coord.serverState.value;
+    final self = coord.selfMember.value;
+    return switch (r?.transport) {
+      'playing' => PlayState.playing,
+      'finished' => PlayState.finished,
+      _ => (self?.ready ?? false) && (self?.inSet ?? false) ? PlayState.waiting : PlayState.paused,
+    };
+  });
+
+  /// Everything the layout depends on (not the position: that changes
+  /// four times a second and only the timeline needs it).
+  late final Computed<ControlsSnapshot> snapshot = computed(() {
+    final items = queue.items.value;
+    final next = coord.nextEpisode.value;
+    return ControlsSnapshot(
+      play: play.value,
+      previousLabel: coord.previousEpisode.value?.label,
+      nextLabel: items.isNotEmpty ? items.first.title : next?.label,
+      nextIsUpNext: items.isNotEmpty,
+      hasChapters: chapters.value.isNotEmpty,
+      hasDuration: duration.value > Duration.zero,
+      solo: SessionState.instance.solo.value,
+      // Not a signal: read again whenever the state changes.
+      hasLink: coord.serverState.value != null && coord.currentLink() != null,
+      fullscreen: fullscreen.value,
+      chatOpen: chatOpen.value,
+    );
+  });
+
+  /// The bar's clusters, in the layout's order.
+  late final Computed<({List<BarControl> left, List<BarControl> right})> bar = computed(
+    () => barControls(snapshot.value, settings.hiddenControls.value),
+  );
+
+  /// What the ⚙ menu lists now.
+  List<ControlAction> menu() => menuActions(snapshot.peek(), settings.hiddenControls.peek());
+
+  /// Ticks on each wheel / key volume step: the skins flash the volume.
+  final volumeFlash = ValueNotifier(0);
+
+  /// A menu of the controls is open (the player's Esc closes it).
+  int menusOpen = 0;
+
+  void dispose() => volumeFlash.dispose();
+
+  // -------------------------------------------------------------- actions
+
+  /// Space: ready / not ready (being ready is "play" in a server).
+  void togglePlay() => coord.toggleReady();
+
+  /// A seek bar's press or drag; through `player.seek`, the user-seek
+  /// path, so everyone follows.
+  void seek(Duration to) => playback.player.seek(to);
+
+  /// Arrow keys: ±[secs], relative to a seek still in flight.
+  void nudge(double secs) => coord.nudge(secs);
+
+  /// +1:30 for everyone.
+  void skipForward() => coord.skipForward();
+
+  /// A skip pill (Skip OP / ED / 1:30).
+  void skip(SkipOffer offer) => coord.skip(offer);
+
+  /// PgDn (+1) / PgUp (-1). False when there is no chapter to go to.
+  bool stepChapter(int delta) => coord.stepChapter(delta);
+
+  void pickChapter(MediaChapter c) => coord.seekTo(c.start.inMicroseconds / 1e6);
+
+  /// Up next's first item, else the next episode. False when neither.
+  bool next() {
+    if (queue.items.peek().isNotEmpty) {
+      queue.skip();
+      return true;
+    }
+    if (coord.nextEpisode.peek() == null) return false;
+    coord.playNextEpisode();
+    return true;
+  }
+
+  /// The previous episode. False without one.
+  bool previous() {
+    if (coord.previousEpisode.peek() == null) return false;
+    coord.playPreviousEpisode();
+    return true;
+  }
+
+  void playNextEpisode() => coord.playNextEpisode();
+
+  void setVolume(double v) => playback.player.setVolume(v.clamp(0.0, vol.maxVolume));
+
+  /// One volume step up (+1) or down (-1) from the wheel or ↑ / ↓;
+  /// flashes the volume readout.
+  void stepVolume(int step) {
+    setVolume(vol.stepVolume(volume.peek(), step * vol.volumeStep));
+    volumeFlash.value++;
+  }
+
+  double _beforeMute = 100;
+
+  /// The speaker: mute, or back to the volume before.
+  void toggleMute() {
+    final v = volume.peek();
+    if (v > 0) {
+      _beforeMute = v;
+      setVolume(0);
+    } else {
+      setVolume(_beforeMute <= 0 ? 100 : _beforeMute);
+    }
+  }
+
+  void pickTrack(TrackPick p) => coord.selectTrack(aid: p.aid, sid: p.sid, subtitlesOff: p.subtitlesOff);
+
+  /// Saved as the choice and applied live; a null quality keeps the
+  /// saved one.
+  void pickShader(ShaderPreset preset, ShaderQuality? quality) => applyShaderChoice(preset, quality);
+
+  void toggleTimeDisplay() => settings.setTimeDisplay(settings.timeDisplay.peek().toggled);
+
+  void toggleFullscreen() => _toggleFullscreen();
+
+  void toggleChat() {
+    coord.markInput();
+    _toggleChat();
+  }
+
+  void changeVideo() => _changeVideo();
+
+  /// Back to the library (keeps playing in the mini player).
+  void collapse() => _collapse();
+
+  /// Asks before leaving the server.
+  void leave() => _leave();
+
+  void reload() {
+    coord.markInput();
+    coord.reloadVideo();
+  }
+
+  void markAllReady() => coord.forcePlayAll();
+
+  String? link() => coord.currentLink();
+}

apps/desktop/lib/src/controls/model/controls_prefs.dart

@@ -0,0 +1,64 @@
+// The player controls' user choices (Settings → Player, stored in
+// `AppSettings`). Plain values: the layout spec and both skins read them.
+
+/// The controls' look. Both skins draw the same controls model in the same
+/// order ([ControlsLayout]); only the look differs.
+enum ControlsSkin {
+  /// Material-style bar: a seek bar over a row of round icon buttons.
+  standard('Standard'),
+
+  /// The app's own timeline skin (inspired by mpv's uosc): a thick band
+  /// with the buffered part, chapters and times, flat glass buttons.
+  minimal('Minimal');
+
+  final String label;
+  const ControlsSkin(this.label);
+
+  /// A stored name; the old `mpvControls` flag (true: the uosc design)
+  /// when there is none.
+  static ControlsSkin fromStored(Object? name, {Object? legacyMpvControls}) {
+    for (final s in values) {
+      if (s.name == name) return s;
+    }
+    return legacyMpvControls == true ? minimal : standard;
+  }
+}
+
+/// The bar's clock: "6:00 / 24:00" or the time left ("-18:00").
+enum TimeDisplay {
+  elapsed('Elapsed / total'),
+  remaining('Remaining');
+
+  final String label;
+  const TimeDisplay(this.label);
+
+  TimeDisplay get toggled => this == elapsed ? remaining : elapsed;
+}
+
+/// Bar and button size.
+enum ControlsSize {
+  normal('Normal', 1.0),
+  large('Large', 1.25);
+
+  final String label;
+  final double scale;
+  const ControlsSize(this.label, this.scale);
+}
+
+/// Bar buttons the user may hide; hidden ones are still in ⚙.
+enum OptionalControl {
+  chapters('Chapter buttons', 'Previous / next chapter (PgUp / PgDn)'),
+  subtitles('Subtitles', 'The subtitle track list'),
+  audio('Audio', 'The audio track list'),
+  chat('Chat', 'Chat & activity (Tab)');
+
+  final String label;
+  final String help;
+  const OptionalControl(this.label, this.help);
+}
+
+/// The auto-hide delays offered (seconds).
+const controlsHideChoices = [2, 3, 5];
+
+/// The default auto-hide delay (seconds).
+const defaultControlsHideSecs = 3;

apps/desktop/lib/src/controls/player_settings.dart

@@ -8,13 +8,15 @@ import '../jellyfin/track_prefs.dart' show MpvTrack;
 import '../playback/playback_controller.dart' show PlaybackController, RenderMode;
 import '../shaders/shader_presets.dart';
 import '../state/session_state.dart';
+import '../shell/mark_problem.dart';
 import '../shell/motion.dart';
 import '../state/settings.dart';
-import 'uosc/buttons.dart';
-import 'uosc/controls.dart';
+import '../widgets/app_menu.dart';
+import 'frame.dart';
+import 'model/controls_prefs.dart';
 
-// Everything about the player, defined once: the rows of the ⚙ card in
-// both control designs and of Settings → Player. Each row reads and
+// Everything about the player, defined once: the rows of the player
+// settings card (⚙ → Player settings, both skins) and of Settings → Player. Each row reads and
 // writes [AppSettings] and applies to a running player right away.
 
 /// One setting: a label, one line of help under it, the control at the
@@ -56,29 +58,16 @@ class SettingRow extends StatelessWidget {
   }
 }
 
-DropdownButton<T> _dropdown<T>({
+AppSelect<T> _dropdown<T>({
   required Key key,
   required T value,
   required List<(T, String)> items,
   required ValueChanged<T> onChanged,
   bool expanded = false,
 }) =>
-    DropdownButton<T>(
-      key: key,
-      value: value,
-      isExpanded: expanded,
-      underline: const SizedBox.shrink(),
-      borderRadius: BorderRadius.circular(10),
-      items: [
-        for (final (v, label) in items)
-          DropdownMenuItem(value: v, child: Text(label, maxLines: 1, overflow: TextOverflow.ellipsis)),
-      ],
-      onChanged: (v) {
-        if (v != null) onChanged(v);
-      },
-    );
+    AppSelect<T>(key: key, value: value, items: items, onChanged: onChanged, expanded: expanded);
 
-/// Standard (our bars over media_kit's controls) or uosc. Live.
+/// The controls' skin: Standard or Minimal. Live.
 class PlayerDesignSetting extends StatelessWidget {
   const PlayerDesignSetting({super.key});
 
@@ -88,12 +77,100 @@ class PlayerDesignSetting extends StatelessWidget {
     return SignalBuilder(
       builder: (context) => SettingRow(
         label: 'Player design',
-        help: 'uosc is modeled on mpv: a thick timeline with chapters and what is cached',
-        control: _dropdown<bool>(
+        help: 'Minimal has a thick timeline with chapters and what is downloaded yet',
+        control: _dropdown<ControlsSkin>(
           key: const ValueKey('player-design'),
-          value: s.mpvControls.value,
-          items: const [(false, 'Standard'), (true, 'uosc')],
-          onChanged: s.setMpvControls,
+          value: s.controlsSkin.value,
+          items: [for (final k in ControlsSkin.values) (k, k.label)],
+          onChanged: s.setControlsSkin,
+        ),
+      ),
+    );
+  }
+}
+
+/// The bar's clock: elapsed / total or the time left. Live.
+class TimeDisplaySetting extends StatelessWidget {
+  const TimeDisplaySetting({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    final s = AppSettings.instance;
+    return SignalBuilder(
+      builder: (context) => SettingRow(
+        label: 'Time display',
+        help: 'Also switched by a click on the time',
+        control: _dropdown<TimeDisplay>(
+          key: const ValueKey('time-display'),
+          value: s.timeDisplay.value,
+          items: [for (final t in TimeDisplay.values) (t, t.label)],
+          onChanged: s.setTimeDisplay,
+        ),
+      ),
+    );
+  }
+}
+
+/// Normal or large bar and buttons. Live.
+class ControlsSizeSetting extends StatelessWidget {
+  const ControlsSizeSetting({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    final s = AppSettings.instance;
+    return SignalBuilder(
+      builder: (context) => SettingRow(
+        label: 'Controls size',
+        help: 'Large makes the bar and its buttons a quarter bigger',
+        control: _dropdown<ControlsSize>(
+          key: const ValueKey('controls-size'),
+          value: s.controlsSize.value,
+          items: [for (final z in ControlsSize.values) (z, z.label)],
+          onChanged: s.setControlsSize,
+        ),
+      ),
+    );
+  }
+}
+
+/// How long the controls stay up without mouse movement. Live.
+class HideDelaySetting extends StatelessWidget {
+  const HideDelaySetting({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    final s = AppSettings.instance;
+    return SignalBuilder(
+      builder: (context) => SettingRow(
+        label: 'Hide the controls after',
+        help: 'Without mouse movement over the video',
+        control: _dropdown<int>(
+          key: const ValueKey('controls-hide'),
+          value: s.controlsHideSecs.value,
+          items: [for (final secs in controlsHideChoices) (secs, '$secs s')],
+          onChanged: s.setControlsHideSecs,
+        ),
+      ),
+    );
+  }
+}
+
+/// One optional bar button on or off (off: it is still in ⚙). Live.
+class BarButtonSetting extends StatelessWidget {
+  final OptionalControl control;
+  const BarButtonSetting({super.key, required this.control});
+
+  @override
+  Widget build(BuildContext context) {
+    final s = AppSettings.instance;
+    return SignalBuilder(
+      builder: (context) => SettingRow(
+        label: control.label,
+        help: control.help,
+        control: Switch(
+          key: ValueKey('bar-${control.name}'),
+          value: !s.hiddenControls.value.contains(control),
+          onChanged: (on) => s.setControlShown(control, on),
         ),
       ),
     );
@@ -307,7 +384,20 @@ class TrackSetting extends StatelessWidget {
   }
 }
 
-/// The player rows of Settings → Player and the ⚙ card, in order.
+/// The controls' own choices (Settings → Player → Controls).
+List<Widget> controlsSettingRows() => [
+  const TimeDisplaySetting(),
+  const ControlsSizeSetting(),
+  const HideDelaySetting(),
+  const Padding(
+    padding: EdgeInsets.only(top: 10, bottom: 2),
+    child: Text('Buttons in the bar (hidden ones stay in ⚙)', style: TextStyle(fontWeight: FontWeight.w600)),
+  ),
+  for (final c in OptionalControl.values) BarButtonSetting(control: c),
+];
+
+/// The player rows of Settings → Player and the player settings card, in
+/// order.
 List<Widget> playerSettingRows({ReadonlySignal<RenderMode>? renderMode}) => [
       const PlayerDesignSetting(),
       const ProgressLineSetting(),
@@ -315,7 +405,8 @@ List<Widget> playerSettingRows({ReadonlySignal<RenderMode>? renderMode}) => [
       const HwdecSetting(),
     ];
 
-/// The ⚙ card: every player setting, plus the running player's tracks.
+/// The player settings card: every player setting, plus the running
+/// player's tracks.
 class PlayerSettingsCard extends StatelessWidget {
   final ReadonlySignal<RenderMode>? renderMode;
   /// Show the audio / subtitle pickers (a player is running).
@@ -324,19 +415,18 @@ class PlayerSettingsCard extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    return Material(
+    // The app's glass, like the Up next popover and the menus.
+    return AppGlass(
       key: const ValueKey('player-settings-card'),
-      elevation: 12,
-      borderRadius: BorderRadius.circular(16),
       child: SizedBox(
         width: 420,
         child: Padding(
-          padding: const EdgeInsets.fromLTRB(18, 14, 18, 10),
+          padding: const EdgeInsets.fromLTRB(16, 12, 16, 10),
           child: Column(
             mainAxisSize: MainAxisSize.min,
             crossAxisAlignment: CrossAxisAlignment.stretch,
             children: [
-              const Text('Player', style: TextStyle(fontWeight: FontWeight.w700, fontSize: 16)),
+              const Text('Player', style: TextStyle(fontWeight: FontWeight.w600, fontSize: 14)),
               const SizedBox(height: 4),
               ...playerSettingRows(renderMode: renderMode),
               if (tracks) ...[
@@ -345,9 +435,16 @@ class PlayerSettingsCard extends StatelessWidget {
                 const TrackSetting(type: JellyfinStreamType.audio),
               ],
               const SizedBox(height: 4),
-              Text(
-                'Custom shader files: Settings → Player',
-                style: TextStyle(color: Theme.of(context).colorScheme.onSurfaceVariant, fontSize: 12),
+              Row(
+                children: [
+                  Expanded(
+                    child: Text(
+                      'Controls layout and custom shaders: Settings → Player',
+                      style: TextStyle(color: Theme.of(context).colorScheme.onSurfaceVariant, fontSize: 12),
+                    ),
+                  ),
+                  const MarkProblemButton(),
+                ],
               ),
             ],
           ),
@@ -357,51 +454,14 @@ class PlayerSettingsCard extends StatelessWidget {
   }
 }
 
-/// Opens the ⚙ card over the player, near the controls' right end. The
-/// uosc controls stay up while it is open.
-Future<void> showPlayerSettings(BuildContext context, {ReadonlySignal<RenderMode>? renderMode}) {
-  Future<void> open() => showPopover<void>(
+/// Opens the player settings card over the player, near the controls'
+/// right end; the controls stay up while it is open.
+Future<void> showPlayerSettings(BuildContext context, {ReadonlySignal<RenderMode>? renderMode}) =>
+    ControlsFrame.holdWhile(
+      context,
+      () => showPopover<void>(
         context,
         at: const Alignment(0.96, 0.5),
         child: PlayerSettingsCard(renderMode: renderMode),
-      );
-  final controls = UoscControls.maybeOf(context);
-  return controls == null ? open() : controls.holdDuring(open);
-}
-
-/// ⚙ in the standard controls' bottom bar.
-class PlayerSettingsButton extends StatelessWidget {
-  final FocusNode? focusNode;
-  final ReadonlySignal<RenderMode>? renderMode;
-  const PlayerSettingsButton({super.key, this.focusNode, this.renderMode});
-
-  @override
-  Widget build(BuildContext context) {
-    return IconButton(
-      key: const ValueKey('player-settings'),
-      focusNode: focusNode,
-      tooltip: 'Player settings',
-      color: Colors.white,
-      iconSize: 20,
-      visualDensity: VisualDensity.compact,
-      icon: const Icon(Icons.tune),
-      onPressed: () => showPlayerSettings(context, renderMode: renderMode),
+      ),
     );
-  }
-}
-
-/// ⚙ in the uosc controls' button row.
-class UoscPlayerSettingsButton extends StatelessWidget {
-  final ReadonlySignal<RenderMode>? renderMode;
-  const UoscPlayerSettingsButton({super.key, this.renderMode});
-
-  @override
-  Widget build(BuildContext context) {
-    return UoscButton(
-      key: const ValueKey('uosc-player-settings'),
-      icon: Icons.tune_rounded,
-      tooltip: 'Player settings',
-      onPressed: () => showPlayerSettings(context, renderMode: renderMode),
-    );
-  }
-}

apps/desktop/lib/src/controls/session_controls.dart

@@ -0,0 +1,83 @@
+import 'package:flutter/material.dart';
+import 'package:signals/signals_flutter.dart';
+
+import '../state/settings.dart';
+import 'controls_probe.dart' show ControlsHold;
+import 'frame.dart';
+import 'minimal/minimal_controls.dart';
+import 'model/controls_model.dart';
+import 'model/controls_prefs.dart';
+import 'standard/standard_controls.dart';
+
+// The session's controls: one [ControlsFrame] (when they are up) around the
+// skin the settings pick, both drawing the same [PlayerControlsModel].
+// Skin, size and the hide delay follow the settings live.
+
+/// The bottom controls' height in [skin] at [size] (the player's floating
+/// pills sit just above it).
+double controlsBottomHeight(ControlsSkin skin, ControlsSize size) => switch (skin) {
+  ControlsSkin.standard => StandardControls.bottomHeight(size.scale),
+  ControlsSkin.minimal => MinimalControls.bottomHeight(size.scale),
+};
+
+/// The top bar's height in [skin].
+double controlsTopHeight(ControlsSkin skin) => switch (skin) {
+  ControlsSkin.standard => StandardControls.topHeight,
+  ControlsSkin.minimal => MinimalControls.topHeight,
+};
+
+class SessionControls extends StatelessWidget {
+  final PlayerControlsModel model;
+
+  /// Follows whether the controls are up.
+  final ValueNotifier<bool> shown;
+  final ControlsHold hold;
+  final VoidCallback onDoubleClick;
+  final Widget? windowButtons;
+  const SessionControls({
+    super.key,
+    required this.model,
+    required this.shown,
+    required this.hold,
+    required this.onDoubleClick,
+    this.windowButtons,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    final s = AppSettings.instance;
+    return SignalBuilder(
+      builder: (context) {
+        final skin = s.controlsSkin.value;
+        final size = s.controlsSize.value;
+        final scale = size.scale;
+        return ControlsFrame(
+          // A new frame per skin: each starts up, like a fresh mount.
+          key: ValueKey(skin),
+          shown: shown,
+          holdBy: hold,
+          hideAfter: Duration(seconds: s.controlsHideSecs.value),
+          onDoubleClick: onDoubleClick,
+          barTop: controlsTopHeight(skin),
+          barBottom: controlsBottomHeight(skin, size),
+          builder: (context, visible) => switch (skin) {
+            ControlsSkin.standard => StandardControls(
+              model: model,
+              visible: visible,
+              scale: scale,
+              hold: hold,
+              windowButtons: windowButtons,
+            ),
+            ControlsSkin.minimal => MinimalControls(
+              model: model,
+              visible: visible,
+              scale: scale,
+              hold: hold,
+              windowButtons: windowButtons,
+            ),
+          },
+        );
+      },
+    );
+  }
+}

apps/desktop/lib/src/controls/standard/seek_bar.dart

@@ -0,0 +1,229 @@
+import 'dart:math' as math;
+
+import 'package:flutter/material.dart';
+
+import '../../playback/media_marks.dart';
+import '../frame.dart';
+
+// The Standard skin's seek bar: a Material-style track with the played and
+// buffered parts, chapter marks and a hover tip.
+
+/// The seek bar: played / buffered track, a diamond at each chapter start
+/// (not the one at 0), and on hover the time with the chapter title above
+/// it. Like media_kit's bar it reports a seek on every drag move and on
+/// release ([onSeek]); the session routes those through the user-seek path
+/// (debounced, everyone follows).
+class ChapterSeekBar extends StatefulWidget {
+  final Duration position;
+  final Duration duration;
+  final Duration buffer;
+  final List<MediaChapter> chapters;
+  final ValueChanged<Duration> onSeek;
+
+  /// The bar's height (its hit area); the track is centred in it.
+  final double height;
+  const ChapterSeekBar({
+    super.key,
+    required this.position,
+    required this.duration,
+    this.buffer = Duration.zero,
+    this.chapters = const [],
+    required this.onSeek,
+    this.height = ChapterSeekBar.defaultHeight,
+  });
+
+  static const defaultHeight = 28.0;
+
+  @override
+  State<ChapterSeekBar> createState() => _ChapterSeekBarState();
+}
+
+class _ChapterSeekBarState extends State<ChapterSeekBar> {
+  double? _hoverX;
+  bool _dragging = false;
+  double _dragFraction = 0;
+
+  double _fraction(Duration d) {
+    final total = widget.duration.inMicroseconds;
+    if (total <= 0) return 0;
+    return (d.inMicroseconds / total).clamp(0.0, 1.0);
+  }
+
+  Duration _at(double fraction) => widget.duration * fraction.clamp(0.0, 1.0);
+
+  // A drag sends no hover events: the controls are held up through it.
+  void _drag(bool on) {
+    if (_dragging == on) return;
+    setState(() => _dragging = on);
+    ControlsFrame.maybeOf(context)?.hold(on);
+  }
+
+  @override
+  void dispose() {
+    if (_dragging) ControlsFrame.maybeOf(context)?.hold(false);
+    super.dispose();
+  }
+
+  void _seekTo(double x, double width) {
+    if (widget.duration <= Duration.zero || width <= 0) return;
+    _dragFraction = (x / width).clamp(0.0, 1.0);
+    widget.onSeek(_at(_dragFraction));
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final primary = Theme.of(context).colorScheme.primary;
+    return LayoutBuilder(
+      builder: (context, constraints) {
+        final width = constraints.maxWidth;
+        final active = _hoverX != null || _dragging;
+        final barHeight = active ? 5.0 : 3.0;
+        final played = _dragging ? _dragFraction : _fraction(widget.position);
+        final mid = widget.height / 2;
+        final hoverX = _hoverX;
+        final hoverAt = hoverX == null || width <= 0 ? null : _at(hoverX / width);
+        final hoverChapter = hoverAt == null ? null : chapterIndexAt(widget.chapters, hoverAt);
+        final hoverTitle = hoverChapter == null ? '' : widget.chapters[hoverChapter].title;
+        return MouseRegion(
+          cursor: SystemMouseCursors.click,
+          onEnter: (e) => setState(() => _hoverX = e.localPosition.dx.clamp(0, width)),
+          onHover: (e) => setState(() => _hoverX = e.localPosition.dx.clamp(0, width)),
+          onExit: (_) => setState(() => _hoverX = null),
+          child: Listener(
+            behavior: HitTestBehavior.opaque,
+            onPointerDown: (e) {
+              _dragFraction = width <= 0 ? 0 : (e.localPosition.dx / width).clamp(0.0, 1.0);
+              _drag(true);
+            },
+            onPointerMove: (e) {
+              setState(() => _hoverX = e.localPosition.dx.clamp(0, width));
+              _seekTo(e.localPosition.dx, width);
+            },
+            onPointerUp: (e) {
+              _seekTo(e.localPosition.dx, width);
+              _drag(false);
+            },
+            onPointerCancel: (_) => _drag(false),
+            child: SizedBox(
+              key: const ValueKey('seek-bar'),
+              width: width,
+              height: widget.height,
+              child: Stack(
+                clipBehavior: Clip.none,
+                children: [
+                  Positioned(
+                    left: 0,
+                    right: 0,
+                    top: mid - barHeight / 2,
+                    height: barHeight,
+                    child: Container(color: Colors.white24),
+                  ),
+                  Positioned(
+                    left: 0,
+                    top: mid - barHeight / 2,
+                    height: barHeight,
+                    width: width * _fraction(widget.buffer),
+                    child: Container(color: Colors.white24),
+                  ),
+                  if (hoverX != null && !_dragging)
+                    Positioned(
+                      left: 0,
+                      top: mid - barHeight / 2,
+                      height: barHeight,
+                      width: hoverX,
+                      child: Container(color: Colors.white24),
+                    ),
+                  Positioned(
+                    left: 0,
+                    top: mid - barHeight / 2,
+                    height: barHeight,
+                    width: width * played,
+                    child: Container(color: primary),
+                  ),
+                  for (final c in widget.chapters)
+                    if (c.start > Duration.zero && widget.duration > Duration.zero)
+                      Positioned(
+                        key: ValueKey('chapter-mark-${c.index}'),
+                        left: width * _fraction(c.start) - 4,
+                        top: mid - 4,
+                        width: 8,
+                        height: 8,
+                        child: IgnorePointer(
+                          child: Transform.rotate(
+                            angle: math.pi / 4,
+                            child: Container(
+                              margin: const EdgeInsets.all(1),
+                              decoration: BoxDecoration(
+                                color: Colors.white,
+                                border: Border.all(color: Colors.black54, width: 0.8),
+                              ),
+                            ),
+                          ),
+                        ),
+                      ),
+                  if (active)
+                    Positioned(
+                      left: width * played - 6,
+                      top: mid - 6,
+                      width: 12,
+                      height: 12,
+                      child: IgnorePointer(
+                        child: DecoratedBox(
+                          decoration: BoxDecoration(color: primary, shape: BoxShape.circle),
+                        ),
+                      ),
+                    ),
+                  if (hoverAt != null)
+                    Positioned(
+                      // Kept clear of the window edges (the tip is centred).
+                      left: hoverX!.clamp(math.min(60.0, width / 2), math.max(width - 60, width / 2)),
+                      bottom: widget.height - 2,
+                      child: IgnorePointer(
+                        child: FractionalTranslation(
+                          translation: const Offset(-0.5, 0),
+                          child: _HoverTip(title: hoverTitle, time: formatClock(hoverAt)),
+                        ),
+                      ),
+                    ),
+                ],
+              ),
+            ),
+          ),
+        );
+      },
+    );
+  }
+}
+
+class _HoverTip extends StatelessWidget {
+  final String title;
+  final String time;
+  const _HoverTip({required this.title, required this.time});
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      constraints: const BoxConstraints(maxWidth: 320),
+      padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
+      decoration: BoxDecoration(color: Colors.black.withValues(alpha: 0.8), borderRadius: BorderRadius.circular(6)),
+      child: Column(
+        mainAxisSize: MainAxisSize.min,
+        children: [
+          if (title.isNotEmpty)
+            Text(
+              title,
+              key: const ValueKey('seek-hover-chapter'),
+              maxLines: 1,
+              overflow: TextOverflow.ellipsis,
+              style: const TextStyle(color: Colors.white, fontSize: 12, fontWeight: FontWeight.w600),
+            ),
+          Text(
+            time,
+            key: const ValueKey('seek-hover-time'),
+            style: const TextStyle(color: Colors.white70, fontSize: 11),
+          ),
+        ],
+      ),
+    );
+  }
+}

apps/desktop/lib/src/controls/standard/standard_controls.dart

@@ -0,0 +1,340 @@
+import 'package:flutter/material.dart';
+import 'package:signals/signals_flutter.dart';
+import 'package:sync_relay_core/core.dart' show JellyfinStreamType;
+
+import '../../queue/queue_ui.dart';
+import '../../shell/now_playing_title.dart';
+import '../../state/settings.dart';
+import '../control_menus.dart';
+import '../controls_probe.dart' show ControlsHold;
+import '../frame.dart';
+import '../model/controls_layout.dart';
+import '../model/controls_model.dart';
+import '../volume.dart';
+import 'seek_bar.dart';
+
+// The Standard skin: Material-style bars over the picture. Top: what plays,
+// Up next and the window controls; bottom: the seek bar (chapter marks,
+// hover time) over a row of round icon buttons in the layout's order.
+// Hidden, a thin progress line stays (unless switched off).
+
+class StandardControls extends StatelessWidget {
+  final PlayerControlsModel model;
+  final bool visible;
+  final double scale;
+  final ControlsHold? hold;
+
+  /// Right of the top bar's own buttons (the window buttons in fullscreen).
+  final Widget? windowButtons;
+  const StandardControls({
+    super.key,
+    required this.model,
+    required this.visible,
+    this.scale = 1,
+    this.hold,
+    this.windowButtons,
+  });
+
+  /// The top bar: room for the cover (2:3, 60 px tall).
+  static const topHeight = 72.0;
+  static const _rowHeight = 56.0;
+
+  /// The bottom bar (seek bar and buttons) at [scale].
+  static double bottomHeight(double scale) => (_rowHeight + ChapterSeekBar.defaultHeight) * scale;
+
+  @override
+  Widget build(BuildContext context) {
+    const fade = ControlsFrame.fade;
+    Widget bar(Widget child) => IgnorePointer(
+      ignoring: !visible,
+      child: AnimatedOpacity(duration: fade, opacity: visible ? 1 : 0, child: child),
+    );
+    // No button here takes focus (Space is the ready key); the top bar's
+    // Up next keeps its own (its popover has a text field).
+    return Stack(
+      children: [
+        Positioned(
+          left: 0,
+          right: 0,
+          top: 0,
+          child: bar(
+            DecoratedBox(
+              decoration: const BoxDecoration(
+                gradient: LinearGradient(
+                  begin: Alignment.topCenter,
+                  end: Alignment.bottomCenter,
+                  colors: [Color(0x99000000), Color(0x00000000)],
+                ),
+              ),
+              child: SizedBox(
+                key: const ValueKey('standard-top'),
+                height: topHeight,
+                child: Padding(padding: const EdgeInsets.only(left: 16, right: 8), child: _top()),
+              ),
+            ),
+          ),
+        ),
+        Positioned(
+          left: 0,
+          right: 0,
+          bottom: 0,
+          child: bar(
+            DecoratedBox(
+              decoration: const BoxDecoration(
+                gradient: LinearGradient(
+                  begin: Alignment.topCenter,
+                  end: Alignment.bottomCenter,
+                  colors: [Color(0x00000000), Color(0xB3000000)],
+                ),
+              ),
+              child: Padding(
+                padding: EdgeInsets.only(top: 24 * scale),
+                child: SizedBox(
+                  key: const ValueKey('standard-bottom'),
+                  height: bottomHeight(scale),
+                  child: Column(
+                    children: [
+                      Padding(
+                        padding: const EdgeInsets.symmetric(horizontal: 16),
+                        child: SignalBuilder(
+                          builder: (context) => ChapterSeekBar(
+                            position: model.position.value,
+                            duration: model.duration.value,
+                            buffer: model.buffered.value,
+                            chapters: model.chapters.value,
+                            height: ChapterSeekBar.defaultHeight * scale,
+                            onSeek: model.seek,
+                          ),
+                        ),
+                      ),
+                      Expanded(
+                        child: Padding(
+                          padding: const EdgeInsets.symmetric(horizontal: 8),
+                          child: ExcludeFocus(
+                            child: SignalBuilder(
+                              builder: (context) {
+                                final s = model.snapshot.value;
+                                final layout = model.bar.value;
+                                return Row(
+                                  key: const ValueKey('standard-buttons'),
+                                  children: [
+                                    for (final c in layout.left) _control(context, c, s),
+                                    const Spacer(),
+                                    for (final c in layout.right) _control(context, c, s),
+                                  ],
+                                );
+                              },
+                            ),
+                          ),
+                        ),
+                      ),
+                    ],
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ),
+        // Hidden: the thin progress line.
+        Positioned(
+          left: 0,
+          right: 0,
+          bottom: 0,
+          child: IgnorePointer(
+            child: SignalBuilder(
+              builder: (context) {
+                if (visible || !AppSettings.instance.progressLine.value) return const SizedBox.shrink();
+                final d = model.duration.value, p = model.position.value;
+                final v = d.inMilliseconds == 0 ? 0.0 : (p.inMilliseconds / d.inMilliseconds).clamp(0.0, 1.0);
+                return LinearProgressIndicator(
+                  key: const ValueKey('progress-line-standard'),
+                  value: v,
+                  minHeight: 2,
+                  backgroundColor: Colors.transparent,
+                );
+              },
+            ),
+          ),
+        ),
+      ],
+    );
+  }
+
+  Widget _top() {
+    final m = model;
+    return Row(
+      children: [
+        const Expanded(child: NowPlayingTitle()),
+        UpNextButton(queue: m.queue, onPlayNextEpisode: m.playNextEpisode, look: UpNextLook.standard, hold: hold),
+        SignalBuilder(
+          builder: (context) {
+            final full = m.fullscreen.value;
+            return ExcludeFocus(
+              child: _IconButton(
+                key: const ValueKey('standard-collapse'),
+                icon: full ? Icons.fullscreen_exit_rounded : Icons.close_fullscreen_rounded,
+                tooltip: full ? 'Exit fullscreen (Esc)' : 'Back to the library (keeps playing)',
+                onPressed: full ? m.toggleFullscreen : m.collapse,
+              ),
+            );
+          },
+        ),
+        ?windowButtons,
+      ],
+    );
+  }
+
+  Widget _control(BuildContext context, BarControl c, ControlsSnapshot s) {
+    final m = model;
+    final key = ValueKey('control-${c.name}');
+    final enabled = controlEnabled(c, s);
+    Widget icon(VoidCallback? onPressed, {int badge = 0, double size = 24, Color? color}) => _IconButton(
+      key: key,
+      icon: controlIcon(c, s),
+      tooltip: controlTooltip(c, s),
+      badge: badge,
+      size: size * scale,
+      color: color,
+      onPressed: enabled ? onPressed : null,
+    );
+    switch (c) {
+      case BarControl.playPause:
+        final waiting = s.play == PlayState.waiting;
+        return icon(m.togglePlay, size: 30, color: waiting ? Theme.of(context).colorScheme.primary : null);
+      case BarControl.previous:
+        return icon(m.previous);
+      case BarControl.next:
+        return icon(m.next);
+      case BarControl.chapterPrevious:
+        return icon(() => m.stepChapter(-1));
+      case BarControl.chapterNext:
+        return icon(() => m.stepChapter(1));
+      case BarControl.volume:
+        return SignalBuilder(
+          key: key,
+          builder: (context) => VolumeControl(
+            volume: m.volume.value,
+            onChanged: m.setVolume,
+            onToggleMute: m.toggleMute,
+            button: (context, i, color, tip, onPressed) =>
+                _IconButton(icon: i, tooltip: tip, color: color, size: 24 * scale, onPressed: onPressed),
+          ),
+        );
+      case BarControl.time:
+        return SignalBuilder(
+          key: key,
+          builder: (context) => _Clock(
+            text: clockText(m.position.value, m.duration.value, m.settings.timeDisplay.value),
+            tooltip: controlTooltip(c, s),
+            scale: scale,
+            onPressed: m.toggleTimeDisplay,
+          ),
+        );
+      case BarControl.subtitles || BarControl.audio:
+        final type = c == BarControl.audio ? JellyfinStreamType.audio : JellyfinStreamType.subtitle;
+        return SignalBuilder(
+          key: key,
+          builder: (context) => Builder(
+            builder: (context) => _IconButton(
+              icon: controlIcon(c, s),
+              tooltip: controlTooltip(c, s),
+              badge: trackCount(m.tracks.value, type),
+              size: 22 * scale,
+              onPressed: () => openTrackMenu(context, m, type),
+            ),
+          ),
+        );
+      case BarControl.settings:
+        return Builder(
+          key: key,
+          builder: (context) => _IconButton(
+            icon: controlIcon(c, s),
+            tooltip: controlTooltip(c, s),
+            size: 22 * scale,
+            onPressed: () => openControlsMenu(context, m),
+          ),
+        );
+      case BarControl.chat:
+        return SignalBuilder(
+          key: key,
+          builder: (context) => _IconButton(
+            icon: controlIcon(c, s),
+            tooltip: controlTooltip(c, s),
+            badge: m.unread.value,
+            size: 22 * scale,
+            onPressed: m.toggleChat,
+          ),
+        );
+      case BarControl.fullscreen:
+        return icon(m.toggleFullscreen, size: 26);
+    }
+  }
+}
+
+/// A round white icon button with an optional count badge (the Material
+/// look of media_kit's bar).
+class _IconButton extends StatelessWidget {
+  final IconData icon;
+  final String tooltip;
+  final VoidCallback? onPressed;
+  final int badge;
+  final double size;
+  final Color? color;
+  const _IconButton({
+    super.key,
+    required this.icon,
+    required this.tooltip,
+    required this.onPressed,
+    this.badge = 0,
+    this.size = 24,
+    this.color,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    final scheme = Theme.of(context).colorScheme;
+    return IconButton(
+      tooltip: tooltip,
+      iconSize: size,
+      color: color ?? Colors.white,
+      disabledColor: Colors.white38,
+      onPressed: onPressed,
+      icon: Badge(
+        isLabelVisible: badge > 0,
+        backgroundColor: scheme.primary,
+        textColor: scheme.onPrimary,
+        label: Text('$badge'),
+        child: Icon(icon),
+      ),
+    );
+  }
+}
+
+/// The clock: "6:00 / 24:00" or "-18:00"; a click switches.
+class _Clock extends StatelessWidget {
+  final String text;
+  final String tooltip;
+  final double scale;
+  final VoidCallback onPressed;
+  const _Clock({required this.text, required this.tooltip, required this.scale, required this.onPressed});
+
+  @override
+  Widget build(BuildContext context) {
+    return Tooltip(
+      message: tooltip,
+      waitDuration: const Duration(milliseconds: 500),
+      child: TextButton(
+        style: TextButton.styleFrom(
+          foregroundColor: Colors.white,
+          padding: EdgeInsets.symmetric(horizontal: 10 * scale),
+          tapTargetSize: MaterialTapTargetSize.shrinkWrap,
+        ),
+        onPressed: onPressed,
+        child: Text(
+          text,
+          style: TextStyle(fontSize: 14 * scale, fontFeatures: const [FontFeature.tabularFigures()]),
+        ),
+      ),
+    );
+  }
+}

apps/desktop/lib/src/controls/uosc/buttons.dart

@@ -1,362 +0,0 @@
-import 'package:flutter/gestures.dart';
-import 'package:flutter/material.dart';
-import 'package:signals/signals_flutter.dart';
-import 'package:sync_relay_core/core.dart' show JellyfinStreamType;
-
-import '../../jellyfin/track_prefs.dart' show MpvTrack;
-import '../../playback/media_marks.dart';
-import '../../playback/playback_controller.dart' show RenderMode;
-import '../../screens/session/player_controls.dart' show TrackPick;
-import '../../shaders/shader_menu.dart';
-import '../../shaders/shader_presets.dart';
-import '../../state/settings.dart';
-import '../volume.dart';
-import 'controls.dart';
-import 'menu.dart';
-import 'style.dart';
-
-/// Flat uosc button: a white icon (optionally a [label] beside it and a
-/// small count [badge] in the corner), a faint highlight on hover, a dark
-/// tooltip. Never takes focus (the session's keys are global).
-class UoscButton extends StatefulWidget {
-  final IconData icon;
-  final String tooltip;
-  final VoidCallback? onPressed;
-  final String? label;
-  final int? badge;
-  /// Tint for an "on" state (ready, shaders on).
-  final Color? color;
-  const UoscButton({
-    super.key,
-    required this.icon,
-    required this.tooltip,
-    required this.onPressed,
-    this.label,
-    this.badge,
-    this.color,
-  });
-
-  @override
-  State<UoscButton> createState() => _UoscButtonState();
-}
-
-class _UoscButtonState extends State<UoscButton> {
-  bool _hover = false;
-
-  @override
-  Widget build(BuildContext context) {
-    final w = widget;
-    final color = w.onPressed == null ? UoscStyle.dim.withValues(alpha: 0.4) : (w.color ?? UoscStyle.text);
-    final badge = w.badge;
-    return UoscTooltip(
-      message: w.tooltip,
-      child: MouseRegion(
-        cursor: w.onPressed == null ? SystemMouseCursors.basic : SystemMouseCursors.click,
-        onEnter: (_) => setState(() => _hover = true),
-        onExit: (_) => setState(() => _hover = false),
-        child: GestureDetector(
-          behavior: HitTestBehavior.opaque,
-          onTap: w.onPressed,
-          child: Container(
-            height: UoscControls.buttonRowHeight,
-            constraints: const BoxConstraints(minWidth: UoscControls.buttonRowHeight),
-            padding: EdgeInsets.symmetric(horizontal: w.label == null ? 0 : 8),
-            decoration: BoxDecoration(
-              color: _hover && w.onPressed != null ? UoscStyle.hover : Colors.transparent,
-              borderRadius: BorderRadius.circular(UoscStyle.radius),
-            ),
-            child: Row(
-              mainAxisSize: MainAxisSize.min,
-              mainAxisAlignment: MainAxisAlignment.center,
-              children: [
-                Stack(
-                  clipBehavior: Clip.none,
-                  children: [
-                    Icon(w.icon, color: color, size: 22),
-                    if (badge != null && badge > 0)
-                      Positioned(
-                        right: -8,
-                        bottom: -5,
-                        child: Container(
-                          key: const ValueKey('uosc-badge'),
-                          padding: const EdgeInsets.symmetric(horizontal: 3),
-                          decoration: BoxDecoration(
-                            color: UoscStyle.text,
-                            borderRadius: BorderRadius.circular(3),
-                          ),
-                          child: Text('$badge',
-                              style: const TextStyle(
-                                  color: Colors.black, fontSize: 9, height: 1.3, fontWeight: FontWeight.w700)),
-                        ),
-                      ),
-                  ],
-                ),
-                if (w.label != null) ...[
-                  const SizedBox(width: 6),
-                  Text(w.label!, style: TextStyle(color: color, fontSize: UoscStyle.fontSize)),
-                ],
-              ],
-            ),
-          ),
-        ),
-      ),
-    );
-  }
-}
-
-/// Badge-style text button ("HQ" in uosc): a small outlined box with a
-/// short label, filled when [active].
-class UoscBadgeButton extends StatefulWidget {
-  final String text;
-  final String tooltip;
-  final bool active;
-  final VoidCallback onPressed;
-  const UoscBadgeButton({
-    super.key,
-    required this.text,
-    required this.tooltip,
-    required this.active,
-    required this.onPressed,
-  });
-
-  @override
-  State<UoscBadgeButton> createState() => _UoscBadgeButtonState();
-}
-
-class _UoscBadgeButtonState extends State<UoscBadgeButton> {
-  bool _hover = false;
-
-  @override
-  Widget build(BuildContext context) {
-    final w = widget;
-    return UoscTooltip(
-      message: w.tooltip,
-      child: MouseRegion(
-        cursor: SystemMouseCursors.click,
-        onEnter: (_) => setState(() => _hover = true),
-        onExit: (_) => setState(() => _hover = false),
-        child: GestureDetector(
-          behavior: HitTestBehavior.opaque,
-          onTap: w.onPressed,
-          child: Container(
-            height: UoscControls.buttonRowHeight,
-            padding: const EdgeInsets.symmetric(horizontal: 6),
-            decoration: BoxDecoration(
-              color: _hover ? UoscStyle.hover : Colors.transparent,
-              borderRadius: BorderRadius.circular(UoscStyle.radius),
-            ),
-            alignment: Alignment.center,
-            child: Container(
-              padding: const EdgeInsets.symmetric(horizontal: 5, vertical: 1),
-              decoration: BoxDecoration(
-                color: w.active ? UoscStyle.text : Colors.transparent,
-                border: Border.all(color: w.active ? UoscStyle.text : UoscStyle.dim, width: 1.4),
-                borderRadius: BorderRadius.circular(3),
-              ),
-              child: Text(w.text,
-                  style: TextStyle(
-                      color: w.active ? Colors.black : UoscStyle.dim,
-                      fontSize: 11,
-                      fontWeight: FontWeight.w800,
-                      letterSpacing: 0.3)),
-            ),
-          ),
-        ),
-      ),
-    );
-  }
-}
-
-/// Volume: click mutes / unmutes, hovering shows a [VolumeBar] up to
-/// [maxVolume], the wheel steps 5 %.
-class UoscVolumeButton extends StatefulWidget {
-  /// 0..[maxVolume].
-  final double volume;
-  final ValueChanged<double> onChanged;
-  const UoscVolumeButton({super.key, required this.volume, required this.onChanged});
-
-  @override
-  State<UoscVolumeButton> createState() => _UoscVolumeButtonState();
-}
-
-class _UoscVolumeButtonState extends State<UoscVolumeButton> {
-  double _beforeMute = 100;
-  bool _hover = false;
-
-  @override
-  Widget build(BuildContext context) {
-    final v = widget.volume;
-    final icon = v <= 0 ? Icons.volume_off_rounded : (v < 50 ? Icons.volume_down_rounded : Icons.volume_up_rounded);
-    return MouseRegion(
-      onEnter: (_) => setState(() => _hover = true),
-      onExit: (_) => setState(() => _hover = false),
-      child: Listener(
-        onPointerSignal: (e) {
-          if (e is PointerScrollEvent && e.scrollDelta.dy != 0) {
-            widget.onChanged(stepVolume(v, e.scrollDelta.dy < 0 ? 5 : -5));
-          }
-        },
-        child: Row(
-          mainAxisSize: MainAxisSize.min,
-          children: [
-            AnimatedSize(
-              duration: const Duration(milliseconds: 150),
-              child: _hover
-                  ? Padding(
-                      padding: const EdgeInsets.only(left: 6, right: 2),
-                      child: VolumeBar(
-                        key: const ValueKey('uosc-volume-bar'),
-                        volume: v,
-                        onChanged: widget.onChanged,
-                        color: UoscStyle.text,
-                        trackColor: UoscStyle.dim.withValues(alpha: 0.5),
-                      ),
-                    )
-                  : const SizedBox.shrink(),
-            ),
-            UoscButton(
-              key: const ValueKey('uosc-volume'),
-              icon: icon,
-              color: v > 100 ? boostColor : null,
-              tooltip: 'Volume ${v.round()} % (scroll to change)',
-              onPressed: () {
-                if (v > 0) {
-                  _beforeMute = v;
-                  widget.onChanged(0);
-                } else {
-                  widget.onChanged(_beforeMute <= 0 ? 100 : _beforeMute);
-                }
-              },
-            ),
-          ],
-        ),
-      ),
-    );
-  }
-}
-
-/// Subtitles or audio: the icon with the track count; the menu lists the
-/// tracks (mpv's selection active).
-class UoscTracksButton extends StatelessWidget {
-  final JellyfinStreamType type;
-  final List<MpvTrack> tracks;
-  final void Function(TrackPick pick) onPick;
-  final ValueChanged<bool>? onMenuOpen;
-  const UoscTracksButton({super.key, required this.type, required this.tracks, required this.onPick, this.onMenuOpen});
-
-  @override
-  Widget build(BuildContext context) {
-    final audio = type == JellyfinStreamType.audio;
-    final count = tracks.where((t) => t.type == type).length;
-    return UoscButton(
-      key: ValueKey(audio ? 'uosc-audio' : 'uosc-subtitles'),
-      icon: audio ? Icons.graphic_eq_rounded : Icons.subtitles_outlined,
-      tooltip: audio ? 'Audio' : 'Subtitles',
-      badge: count,
-      onPressed: () async {
-        onMenuOpen?.call(true);
-        final pick = await showUoscMenu<TrackPick>(context,
-            title: audio ? 'Audio' : 'Subtitles', items: trackMenuItems(type, tracks));
-        onMenuOpen?.call(false);
-        if (pick != null) onPick(pick);
-      },
-    );
-  }
-}
-
-/// Chapters: the list with start times, the playing one active; a pick
-/// jumps there. Nothing without chapters.
-class UoscChaptersButton extends StatelessWidget {
-  final List<MediaChapter> chapters;
-  final int? current;
-  final Duration duration;
-  final ValueChanged<MediaChapter> onPick;
-  final ValueChanged<bool>? onMenuOpen;
-  const UoscChaptersButton({
-    super.key,
-    required this.chapters,
-    required this.current,
-    required this.duration,
-    required this.onPick,
-    this.onMenuOpen,
-  });
-
-  @override
-  Widget build(BuildContext context) {
-    if (chapters.isEmpty) return const SizedBox.shrink();
-    return UoscButton(
-      key: const ValueKey('uosc-chapters'),
-      icon: Icons.bookmarks_outlined,
-      tooltip: 'Chapters (PgUp / PgDn)',
-      onPressed: () async {
-        onMenuOpen?.call(true);
-        final pick = await showUoscMenu<MediaChapter>(context,
-            title: 'Chapters', items: chapterMenuItems(chapters, current, duration));
-        onMenuOpen?.call(false);
-        if (pick != null) onPick(pick);
-      },
-    );
-  }
-}
-
-/// Shaders as uosc's quality badge: the active Anime4K preset ("A HQ"),
-/// "4K" dimmed when off. Opens the shader menu.
-class UoscShaderButton extends StatelessWidget {
-  final ReadonlySignal<RenderMode> renderMode;
-  final void Function(ShaderPreset preset, ShaderQuality? quality) onPick;
-  final ValueChanged<bool>? onMenuOpen;
-  const UoscShaderButton({super.key, required this.renderMode, required this.onPick, this.onMenuOpen});
-
-  @override
-  Widget build(BuildContext context) {
-    final s = AppSettings.instance;
-    return SignalBuilder(builder: (context) {
-      final preset = s.shaderPreset.value;
-      final quality = s.shaderQuality.value;
-      final short = shaderShortLabel(preset, quality);
-      return Builder(
-        builder: (context) => UoscBadgeButton(
-          key: const ValueKey('uosc-shaders'),
-          text: short ?? '4K',
-          active: short != null,
-          tooltip: short == null
-              ? 'Shaders: off (Ctrl+1..6)'
-              : 'Shaders: ${shaderLabel(preset, quality)} (Ctrl+0 off)',
-          onPressed: () {
-            final controls = UoscControls.maybeOf(context);
-            Future<void> open() =>
-                showShaderMenu(context, renderMode: renderMode, onPick: onPick, onMenuOpen: onMenuOpen);
-            controls == null ? open() : controls.holdDuring(open);
-          },
-        ),
-      );
-    });
-  }
-}
-
-/// One entry of the ≡ menu.
-typedef UoscAction = ({String title, String? hint, VoidCallback run});
-
-/// ≡: the session's actions as a menu.
-class UoscMainMenuButton extends StatelessWidget {
-  final List<UoscAction> actions;
-  final ValueChanged<bool>? onMenuOpen;
-  const UoscMainMenuButton({super.key, required this.actions, this.onMenuOpen});
-
-  @override
-  Widget build(BuildContext context) {
-    return UoscButton(
-      key: const ValueKey('uosc-menu-button'),
-      icon: Icons.menu_rounded,
-      tooltip: 'Menu',
-      onPressed: () async {
-        onMenuOpen?.call(true);
-        final pick = await showUoscMenu<UoscAction>(context, items: [
-          for (final a in actions) UoscMenuItem(value: a, title: a.title, hint: a.hint),
-        ]);
-        onMenuOpen?.call(false);
-        pick?.run();
-      },
-    );
-  }
-}

apps/desktop/lib/src/controls/uosc/controls.dart

@@ -1,265 +0,0 @@
-import 'dart:async';
-
-import 'package:flutter/material.dart';
-import 'package:signals/signals_flutter.dart';
-
-import '../../state/settings.dart';
-
-// The mpv-style (uosc) controls frame: a full-width timeline at the
-// bottom with a row of flat buttons above it, the title top left and a
-// corner widget top right.
-// Mouse movement shows them; after [UoscControls.hideAfter] without any
-// they fade out, the timeline shrinks to a 2 px line (gone when "Progress
-// line when hidden" is off) and the cursor hides. Our own frame: no
-// media_kit controls state to reach into.
-
-class UoscControls extends StatefulWidget {
-  /// The timeline; [expanded] is false while the controls are hidden.
-  final Widget Function(BuildContext context, bool expanded) timeline;
-  /// Buttons left and right of the row above the timeline.
-  final List<Widget> left;
-  final List<Widget> right;
-  /// Top-right corner (chat, back to the library), shown with the controls.
-  final Widget? top;
-  /// Top left (what is playing), shown with the controls; gets the width
-  /// [top] leaves.
-  final Widget? topLeft;
-  final VoidCallback? onDoubleTap;
-  final Duration hideAfter;
-  /// Follows whether the controls are up (for overlays outside them).
-  final ValueNotifier<bool>? shown;
-  const UoscControls({
-    super.key,
-    required this.timeline,
-    this.left = const [],
-    this.right = const [],
-    this.top,
-    this.topLeft,
-    this.onDoubleTap,
-    this.hideAfter = const Duration(seconds: 3),
-    this.shown,
-  });
-
-  static const buttonRowHeight = 40.0;
-
-  /// The controls around [context], for widgets that need them kept up
-  /// (a timeline drag, an open menu).
-  static UoscControlsState? maybeOf(BuildContext context) =>
-      context.findAncestorStateOfType<UoscControlsState>();
-
-  @override
-  State<UoscControls> createState() => UoscControlsState();
-}
-
-class UoscControlsState extends State<UoscControls> {
-  bool _visible = true;
-  int _holds = 0;
-  Timer? _timer;
-
-  bool get visible => _visible;
-
-  @override
-  void initState() {
-    super.initState();
-    // Not during this build: an overlay listening to [shown] may be built.
-    WidgetsBinding.instance.addPostFrameCallback((_) {
-      if (mounted) widget.shown?.value = true;
-    });
-    _hideLater();
-  }
-
-  @override
-  void dispose() {
-    _timer?.cancel();
-    super.dispose();
-  }
-
-  /// Show the controls and restart the hide countdown.
-  void wake() {
-    if (!_visible && mounted) {
-      setState(() => _visible = true);
-      widget.shown?.value = true;
-    }
-    _hideLater();
-  }
-
-  /// Keep the controls up while [on] (paired calls): a drag sends no
-  /// hover events and a menu route takes the mouse.
-  void hold(bool on) {
-    _holds = on ? _holds + 1 : (_holds - 1).clamp(0, 1 << 20);
-    wake();
-  }
-
-  /// Runs [open] (a menu) with the controls held up.
-  Future<T> holdDuring<T>(Future<T> Function() open) async {
-    hold(true);
-    try {
-      return await open();
-    } finally {
-      if (mounted) hold(false);
-    }
-  }
-
-  void _hideLater() {
-    _timer?.cancel();
-    _timer = Timer(widget.hideAfter, _hide);
-  }
-
-  void _hide() {
-    if (!mounted || _holds > 0 || !_visible) return;
-    setState(() => _visible = false);
-    widget.shown?.value = false;
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    final visible = _visible;
-    const fade = Duration(milliseconds: 150);
-    return MouseRegion(
-      cursor: visible ? SystemMouseCursors.basic : SystemMouseCursors.none,
-      onEnter: (_) => wake(),
-      onHover: (_) => wake(),
-      onExit: (_) {
-        _timer?.cancel();
-        _hide();
-      },
-      child: Stack(
-        children: [
-          Positioned.fill(
-            child: GestureDetector(
-              behavior: HitTestBehavior.opaque,
-              onDoubleTap: widget.onDoubleTap,
-            ),
-          ),
-          Positioned(
-            left: 0,
-            right: 0,
-            bottom: 0,
-            height: 160,
-            child: IgnorePointer(
-              child: AnimatedOpacity(
-                duration: fade,
-                opacity: visible ? 1 : 0,
-                child: const DecoratedBox(
-                  decoration: BoxDecoration(
-                    gradient: LinearGradient(
-                      begin: Alignment.topCenter,
-                      end: Alignment.bottomCenter,
-                      colors: [Color(0x00000000), Color(0x8C000000)],
-                    ),
-                  ),
-                ),
-              ),
-            ),
-          ),
-          if (widget.topLeft != null)
-            Positioned(
-              left: 0,
-              right: 0,
-              top: 0,
-              height: 120,
-              child: IgnorePointer(
-                child: AnimatedOpacity(
-                  duration: fade,
-                  opacity: visible ? 1 : 0,
-                  child: const DecoratedBox(
-                    decoration: BoxDecoration(
-                      gradient: LinearGradient(
-                        begin: Alignment.topCenter,
-                        end: Alignment.bottomCenter,
-                        colors: [Color(0x8C000000), Color(0x00000000)],
-                      ),
-                    ),
-                  ),
-                ),
-              ),
-            ),
-          if (widget.top != null || widget.topLeft != null)
-            Positioned(
-              top: 0,
-              left: 0,
-              right: 0,
-              child: IgnorePointer(
-                key: const ValueKey('uosc-top'),
-                ignoring: !visible,
-                child: AnimatedOpacity(
-                  duration: fade,
-                  opacity: visible ? 1 : 0,
-                  child: Row(
-                    crossAxisAlignment: CrossAxisAlignment.start,
-                    children: [
-                      Expanded(
-                        child: Padding(
-                          padding: const EdgeInsets.fromLTRB(16, 12, 16, 0),
-                          child: widget.topLeft == null
-                              ? const SizedBox.shrink()
-                              : Align(alignment: AlignmentDirectional.centerStart, child: widget.topLeft),
-                        ),
-                      ),
-                      ?widget.top,
-                    ],
-                  ),
-                ),
-              ),
-            ),
-          Positioned(
-            left: 0,
-            right: 0,
-            bottom: 0,
-            child: Column(
-              mainAxisSize: MainAxisSize.min,
-              crossAxisAlignment: CrossAxisAlignment.stretch,
-              children: [
-                IgnorePointer(
-                  key: const ValueKey('uosc-buttons'),
-                  ignoring: !visible,
-                  child: AnimatedOpacity(
-                    duration: fade,
-                    opacity: visible ? 1 : 0,
-                    child: Padding(
-                      padding: const EdgeInsets.fromLTRB(6, 0, 6, 4),
-                      child: SizedBox(
-                        height: UoscControls.buttonRowHeight,
-                        child: Row(children: [...widget.left, const Spacer(), ...widget.right]),
-                      ),
-                    ),
-                  ),
-                ),
-                // Hidden: the collapsed timeline is the progress line,
-                // unless the player settings turn it off.
-                SignalBuilder(
-                  builder: (context) {
-                    final line = AppSettings.instance.progressLine.value;
-                    return AnimatedOpacity(
-                      key: const ValueKey('uosc-timeline-wrap'),
-                      duration: fade,
-                      opacity: visible || line ? 1 : 0,
-                      child: widget.timeline(context, visible),
-                    );
-                  },
-                ),
-              ],
-            ),
-          ),
-        ],
-      ),
-    );
-  }
-}
-
-/// The session's controls: the standard ones ([material]) or, with the
-/// "Player design" setting on uosc, the uosc ones ([mpv]). Switches live
-/// when the setting changes.
-class SessionControlsSwitch extends StatelessWidget {
-  final WidgetBuilder material;
-  final WidgetBuilder mpv;
-  const SessionControlsSwitch({super.key, required this.material, required this.mpv});
-
-  @override
-  Widget build(BuildContext context) {
-    return SignalBuilder(
-      builder: (context) =>
-          AppSettings.instance.mpvControls.value ? mpv(context) : material(context),
-    );
-  }
-}

apps/desktop/lib/src/controls/uosc/menu.dart

@@ -1,249 +0,0 @@
-import 'dart:math' as math;
-
-import 'package:flutter/material.dart';
-import 'package:sync_relay_core/core.dart' show JellyfinStreamType;
-
-import '../../jellyfin/track_prefs.dart' show MpvTrack;
-import '../../playback/media_marks.dart';
-import '../../screens/session/player_controls.dart' show TrackPick;
-import 'controls.dart';
-import 'style.dart';
-
-/// One row of a uosc menu: [title], a dim [hint] on the right (a time, a
-/// key), [active] = the current one (highlighted).
-class UoscMenuItem<T> {
-  final T value;
-  final String title;
-  final String? hint;
-  final bool active;
-  final bool enabled;
-  const UoscMenuItem({
-    required this.value,
-    required this.title,
-    this.hint,
-    this.active = false,
-    this.enabled = true,
-  });
-}
-
-/// A flat dark menu over the controls, above the widget of [context] (the
-/// button that opens it), with an optional [title] row. Resolves to the
-/// picked value, or null when dismissed (click outside, Esc). Keeps the
-/// controls up while open.
-Future<T?> showUoscMenu<T>(
-  BuildContext context, {
-  String? title,
-  required List<UoscMenuItem<T>> items,
-}) {
-  final navigator = Navigator.of(context);
-  final overlay = navigator.overlay!.context.findRenderObject() as RenderBox;
-  final box = context.findRenderObject() as RenderBox;
-  final anchor = Rect.fromPoints(
-    box.localToGlobal(Offset.zero, ancestor: overlay),
-    box.localToGlobal(box.size.bottomRight(Offset.zero), ancestor: overlay),
-  );
-  Future<T?> open() => navigator.push<T>(_UoscMenuRoute<T>(anchor: anchor, title: title, items: items));
-  final controls = UoscControls.maybeOf(context);
-  return controls == null ? open() : controls.holdDuring(open);
-}
-
-class _UoscMenuRoute<T> extends PopupRoute<T> {
-  final Rect anchor;
-  final String? title;
-  final List<UoscMenuItem<T>> items;
-  _UoscMenuRoute({required this.anchor, required this.title, required this.items});
-
-  @override
-  Color? get barrierColor => null;
-
-  @override
-  bool get barrierDismissible => true;
-
-  @override
-  String? get barrierLabel => 'Close menu';
-
-  @override
-  Duration get transitionDuration => Duration.zero;
-
-  @override
-  Widget buildPage(BuildContext context, Animation<double> animation, Animation<double> secondaryAnimation) {
-    return LayoutBuilder(builder: (context, constraints) {
-      const width = 360.0;
-      final screen = constraints.biggest;
-      final left = anchor.left.clamp(8.0, math.max(8.0, screen.width - width - 8));
-      final maxHeight = math.max(120.0, anchor.top - 16);
-      return Stack(
-        children: [
-          Positioned(
-            left: left.toDouble(),
-            bottom: screen.height - anchor.top + 6,
-            width: math.min(width, screen.width - 16),
-            child: ConstrainedBox(
-              constraints: BoxConstraints(maxHeight: maxHeight),
-              child: UoscMenuPanel<T>(
-                title: title,
-                items: items,
-                onPick: (v) => Navigator.of(context).pop(v),
-              ),
-            ),
-          ),
-        ],
-      );
-    });
-  }
-}
-
-/// The menu's panel alone (tests pump it without a route).
-class UoscMenuPanel<T> extends StatefulWidget {
-  final String? title;
-  final List<UoscMenuItem<T>> items;
-  final ValueChanged<T> onPick;
-  const UoscMenuPanel({super.key, this.title, required this.items, required this.onPick});
-
-  static const rowHeight = 36.0;
-
-  @override
-  State<UoscMenuPanel<T>> createState() => _UoscMenuPanelState<T>();
-}
-
-class _UoscMenuPanelState<T> extends State<UoscMenuPanel<T>> {
-  // Long lists open on the current row.
-  late final _scroll = ScrollController(
-      initialScrollOffset: math.max(0, widget.items.indexWhere((i) => i.active) - 3) * UoscMenuPanel.rowHeight);
-
-  @override
-  void dispose() {
-    _scroll.dispose();
-    super.dispose();
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    final title = widget.title;
-    return Material(
-      key: const ValueKey('uosc-menu'),
-      color: UoscStyle.panel,
-      borderRadius: BorderRadius.circular(UoscStyle.radius * 2),
-      clipBehavior: Clip.antiAlias,
-      child: Column(
-        mainAxisSize: MainAxisSize.min,
-        crossAxisAlignment: CrossAxisAlignment.stretch,
-        children: [
-          if (title != null)
-            Container(
-              height: 34,
-              alignment: Alignment.center,
-              decoration: const BoxDecoration(border: Border(bottom: BorderSide(color: Color(0x22FFFFFF)))),
-              child: Text(title,
-                  style: const TextStyle(color: UoscStyle.dim, fontSize: UoscStyle.fontSize, fontWeight: FontWeight.w600)),
-            ),
-          Flexible(
-            child: ListView.builder(
-              shrinkWrap: true,
-              padding: const EdgeInsets.all(4),
-              controller: _scroll,
-              itemCount: widget.items.length,
-              itemExtent: UoscMenuPanel.rowHeight,
-              itemBuilder: (context, i) => _Row<T>(item: widget.items[i], onPick: widget.onPick),
-            ),
-          ),
-        ],
-      ),
-    );
-  }
-}
-
-class _Row<T> extends StatefulWidget {
-  final UoscMenuItem<T> item;
-  final ValueChanged<T> onPick;
-  const _Row({super.key, required this.item, required this.onPick});
-
-  @override
-  State<_Row<T>> createState() => _RowState<T>();
-}
-
-class _RowState<T> extends State<_Row<T>> {
-  bool _hover = false;
-
-  @override
-  Widget build(BuildContext context) {
-    final item = widget.item;
-    final color = item.active
-        ? UoscStyle.fill
-        : _hover && item.enabled
-            ? UoscStyle.hover
-            : Colors.transparent;
-    final textColor = item.enabled ? UoscStyle.text : UoscStyle.dim.withValues(alpha: 0.4);
-    return MouseRegion(
-      cursor: item.enabled ? SystemMouseCursors.click : SystemMouseCursors.basic,
-      onEnter: (_) => setState(() => _hover = true),
-      onExit: (_) => setState(() => _hover = false),
-      child: GestureDetector(
-        key: ValueKey('uosc-menu-item-${item.title}'),
-        behavior: HitTestBehavior.opaque,
-        onTap: item.enabled ? () => widget.onPick(item.value) : null,
-        child: Container(
-          padding: const EdgeInsets.symmetric(horizontal: 10),
-          decoration: BoxDecoration(color: color, borderRadius: BorderRadius.circular(UoscStyle.radius)),
-          child: Row(
-            children: [
-              Expanded(
-                child: Text(item.title,
-                    maxLines: 1,
-                    overflow: TextOverflow.ellipsis,
-                    style: TextStyle(
-                        color: textColor,
-                        fontSize: UoscStyle.fontSize,
-                        fontWeight: item.active ? FontWeight.w600 : FontWeight.normal)),
-              ),
-              if (item.hint != null) ...[
-                const SizedBox(width: 12),
-                Text(item.hint!,
-                    style: TextStyle(
-                        color: item.active ? UoscStyle.text : UoscStyle.dim,
-                        fontSize: 12,
-                        fontFeatures: const [FontFeature.tabularFigures()])),
-              ],
-            ],
-          ),
-        ),
-      ),
-    );
-  }
-}
-
-/// Chapters with their start times, the playing one active.
-List<UoscMenuItem<MediaChapter>> chapterMenuItems(List<MediaChapter> chapters, int? current, Duration duration) {
-  final withHours = duration >= const Duration(hours: 1);
-  return [
-    for (final c in chapters)
-      UoscMenuItem(
-        value: c,
-        title: c.title.isEmpty ? 'Chapter ${c.index + 1}' : c.title,
-        hint: formatUoscTime(c.start, withHours: withHours),
-        active: c.index == current,
-      ),
-  ];
-}
-
-/// The audio or subtitle tracks ("Japanese · E-AC3 2.0 · title"), mpv's
-/// selection active; subtitles start with Off.
-List<UoscMenuItem<TrackPick>> trackMenuItems(JellyfinStreamType type, List<MpvTrack> tracks) {
-  final audio = type == JellyfinStreamType.audio;
-  final list = tracks.where((t) => t.type == type).toList();
-  return [
-    if (!audio)
-      UoscMenuItem(
-        value: (aid: null, sid: null, subtitlesOff: true),
-        title: 'Off',
-        active: !list.any((t) => t.selected),
-      ),
-    for (final t in list)
-      UoscMenuItem(
-        value: audio ? (aid: t.id, sid: null, subtitlesOff: false) : (aid: null, sid: t.id, subtitlesOff: false),
-        title: t.label,
-        hint: '#${t.id}',
-        active: t.selected,
-      ),
-  ];
-}

apps/desktop/lib/src/controls/uosc/style.dart

@@ -1,79 +0,0 @@
-import 'package:flutter/material.dart';
-
-// Look of the experimental mpv-style controls, after the uosc theme as the
-// owner runs it: flat black panels, white icons, a muted blue fill.
-
-abstract final class UoscStyle {
-  /// Timeline background and the boxes on it.
-  static const bar = Color(0xCC000000);
-  /// Played part of the timeline; also the active menu row.
-  static const fill = Color(0xFF4C6A8E);
-  /// Menus and tooltips.
-  static const panel = Color(0xF0101010);
-  static const hover = Color(0x24FFFFFF);
-  static const text = Colors.white;
-  static const dim = Color(0xA6FFFFFF);
-  static const radius = 4.0;
-  static const fontSize = 13.0;
-}
-
-/// uosc's clock: "01:51", "1:02:03" style but zero-padded ("01:02:03")
-/// once [withHours] (the media is an hour or longer).
-String formatUoscTime(Duration d, {bool withHours = false}) {
-  final t = d.isNegative ? Duration.zero : d;
-  String two(int n) => n.toString().padLeft(2, '0');
-  final h = t.inHours, m = t.inMinutes % 60, s = t.inSeconds % 60;
-  return withHours || h > 0 ? '${two(h)}:${two(m)}:${two(s)}' : '${two(m)}:${two(s)}';
-}
-
-/// Dark rounded hover tip ("Subtitles"), shown above its child.
-class UoscTooltip extends StatelessWidget {
-  final String message;
-  final Widget child;
-  const UoscTooltip({super.key, required this.message, required this.child});
-
-  @override
-  Widget build(BuildContext context) {
-    if (message.isEmpty) return child;
-    return Tooltip(
-      message: message,
-      preferBelow: false,
-      verticalOffset: 26,
-      waitDuration: const Duration(milliseconds: 250),
-      padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
-      decoration: BoxDecoration(
-        color: UoscStyle.panel,
-        borderRadius: BorderRadius.circular(UoscStyle.radius),
-      ),
-      textStyle: const TextStyle(color: UoscStyle.text, fontSize: 12),
-      child: child,
-    );
-  }
-}
-
-/// A small dark box with one line of text (the timeline's times, the
-/// hover chapter title).
-class UoscBox extends StatelessWidget {
-  final String text;
-  final Color color;
-  final TextStyle style;
-  const UoscBox(
-    this.text, {
-    super.key,
-    this.color = UoscStyle.panel,
-    this.style = const TextStyle(color: UoscStyle.text, fontSize: UoscStyle.fontSize),
-  });
-
-  @override
-  Widget build(BuildContext context) {
-    return Container(
-      constraints: const BoxConstraints(maxWidth: 360),
-      padding: const EdgeInsets.symmetric(horizontal: 7, vertical: 3),
-      decoration: BoxDecoration(color: color, borderRadius: BorderRadius.circular(UoscStyle.radius)),
-      child: Text(text,
-          maxLines: 1,
-          overflow: TextOverflow.ellipsis,
-          style: style.copyWith(fontFeatures: const [FontFeature.tabularFigures()])),
-    );
-  }
-}

apps/desktop/lib/src/controls/uosc/timeline.dart

@@ -1,287 +0,0 @@
-import 'dart:math' as math;
-
-import 'package:flutter/material.dart';
-
-import '../../playback/media_marks.dart';
-import 'controls.dart';
-import 'style.dart';
-
-/// Fraction of [total] at [d], 0..1 (0 without a duration).
-double timelineFraction(Duration d, Duration total) {
-  final t = total.inMicroseconds;
-  if (t <= 0) return 0;
-  return (d.inMicroseconds / t).clamp(0.0, 1.0);
-}
-
-/// The cached-ahead part of a timeline of [size]: from the playing
-/// position to the end of mpv's cache. Null when nothing is cached ahead.
-Rect? cacheRect(Size size, {required Duration position, required Duration buffered, required Duration duration}) {
-  final from = timelineFraction(position, duration) * size.width;
-  final to = timelineFraction(buffered, duration) * size.width;
-  if (to - from < 0.5) return null;
-  return Rect.fromLTRB(from, 0, to, size.height);
-}
-
-/// The hatching of [r]: 45° strokes from bottom-left to top-right,
-/// [spacing] apart along x, across all of [r] (the painter clips them).
-/// The first starts half a step in, so none just grazes the corner.
-List<(Offset, Offset)> hatchLines(Rect r, {double spacing = 6}) {
-  if (r.isEmpty || spacing <= 0) return const [];
-  final h = r.height;
-  return [
-    for (var x = r.left - h + spacing / 2; x < r.right; x += spacing) (Offset(x, r.bottom), Offset(x + h, r.top)),
-  ];
-}
-
-/// The uosc timeline: full width, elapsed part filled, the cached range
-/// ahead hatched, chapter starts as white diamonds on the top edge, the
-/// current time in a box at the left and the duration at the right.
-/// Hover shows the chapter title over the hover time. When the controls
-/// hide ([expanded] false) it shrinks to a thin line with chapter ticks.
-/// Like the media_kit bar it reports a seek on every drag move and on
-/// release ([onSeek]); the session sends those through the user-seek path.
-class UoscTimeline extends StatefulWidget {
-  final Duration position;
-  final Duration duration;
-  /// End of the cached range ([PlaybackController.buffered]).
-  final Duration buffered;
-  final List<MediaChapter> chapters;
-  final bool expanded;
-  final ValueChanged<Duration> onSeek;
-  const UoscTimeline({
-    super.key,
-    required this.position,
-    required this.duration,
-    this.buffered = Duration.zero,
-    this.chapters = const [],
-    this.expanded = true,
-    required this.onSeek,
-  });
-
-  static const height = 30.0;
-  static const collapsedHeight = 2.0;
-
-  @override
-  State<UoscTimeline> createState() => _UoscTimelineState();
-}
-
-class _UoscTimelineState extends State<UoscTimeline> {
-  double? _hoverX;
-  bool _dragging = false;
-  double _dragFraction = 0;
-
-  Duration _at(double fraction) => widget.duration * fraction.clamp(0.0, 1.0);
-
-  void _seekTo(double x, double width) {
-    if (widget.duration <= Duration.zero || width <= 0) return;
-    _dragFraction = (x / width).clamp(0.0, 1.0);
-    widget.onSeek(_at(_dragFraction));
-  }
-
-  void _drag(bool on) {
-    if (_dragging == on) return;
-    setState(() => _dragging = on);
-    UoscControls.maybeOf(context)?.hold(on);
-  }
-
-  @override
-  void didUpdateWidget(UoscTimeline old) {
-    super.didUpdateWidget(old);
-    if (!widget.expanded && old.expanded) _hoverX = null;
-  }
-
-  @override
-  void dispose() {
-    // A drag cut short by a rebuild must not keep the controls up.
-    if (_dragging) UoscControls.maybeOf(context)?.hold(false);
-    super.dispose();
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    return LayoutBuilder(builder: (context, constraints) {
-      final width = constraints.maxWidth;
-      final expanded = widget.expanded;
-      final h = expanded ? UoscTimeline.height : UoscTimeline.collapsedHeight;
-      final played = _dragging ? _dragFraction : timelineFraction(widget.position, widget.duration);
-      final hoverX = expanded ? _hoverX : null;
-      final hoverAt = hoverX == null || width <= 0 ? null : _at(hoverX / width);
-      final hoverChapter = hoverAt == null ? null : chapterIndexAt(widget.chapters, hoverAt);
-      final hoverTitle = hoverChapter == null ? '' : widget.chapters[hoverChapter].title;
-      final withHours = widget.duration >= const Duration(hours: 1);
-      final marks = [
-        for (final c in widget.chapters)
-          if (c.start > Duration.zero && widget.duration > Duration.zero) c,
-      ];
-      final bar = SizedBox(
-        key: const ValueKey('uosc-timeline'),
-        width: width,
-        height: h,
-        child: Stack(
-          clipBehavior: Clip.none,
-          children: [
-            Positioned.fill(
-              child: CustomPaint(
-                painter: UoscTimelinePainter(
-                  played: played,
-                  cache: (size) => cacheRect(size,
-                      position: widget.position, buffered: widget.buffered, duration: widget.duration),
-                  cacheKey: (widget.position, widget.buffered, widget.duration),
-                  hoverX: _dragging ? null : hoverX,
-                  hatched: expanded,
-                ),
-              ),
-            ),
-            for (final c in marks)
-              if (expanded)
-                Positioned(
-                  key: ValueKey('uosc-chapter-${c.index}'),
-                  left: width * timelineFraction(c.start, widget.duration) - 4,
-                  top: -4,
-                  width: 8,
-                  height: 8,
-                  child: IgnorePointer(
-                    child: Transform.rotate(
-                      angle: math.pi / 4,
-                      child: Container(
-                        margin: const EdgeInsets.all(1.2),
-                        decoration: BoxDecoration(
-                          color: Colors.white,
-                          border: Border.all(color: Colors.black54, width: 0.6),
-                        ),
-                      ),
-                    ),
-                  ),
-                )
-              else
-                Positioned(
-                  key: ValueKey('uosc-chapter-tick-${c.index}'),
-                  left: width * timelineFraction(c.start, widget.duration) - 1,
-                  top: -2,
-                  width: 2,
-                  height: h + 2,
-                  child: const IgnorePointer(child: ColoredBox(color: Colors.white70)),
-                ),
-            if (expanded) ...[
-              Positioned(
-                left: 4,
-                top: 0,
-                bottom: 0,
-                child: IgnorePointer(
-                  child: Center(
-                    child: UoscBox(formatUoscTime(_at(played), withHours: withHours),
-                        key: const ValueKey('uosc-time'), color: UoscStyle.bar),
-                  ),
-                ),
-              ),
-              Positioned(
-                right: 4,
-                top: 0,
-                bottom: 0,
-                child: IgnorePointer(
-                  child: Center(
-                    child: UoscBox(formatUoscTime(widget.duration, withHours: withHours),
-                        key: const ValueKey('uosc-duration'), color: UoscStyle.bar),
-                  ),
-                ),
-              ),
-            ],
-            if (hoverAt != null)
-              Positioned(
-                // Kept clear of the window edges (the tip is centred).
-                left: hoverX!.clamp(math.min(60.0, width / 2), math.max(width - 60, width / 2)),
-                bottom: h + 8,
-                child: IgnorePointer(
-                  child: FractionalTranslation(
-                    translation: const Offset(-0.5, 0),
-                    child: Column(
-                      mainAxisSize: MainAxisSize.min,
-                      spacing: 4,
-                      children: [
-                        if (hoverTitle.isNotEmpty) UoscBox(hoverTitle, key: const ValueKey('uosc-hover-chapter')),
-                        UoscBox(formatUoscTime(hoverAt, withHours: withHours),
-                            key: const ValueKey('uosc-hover-time')),
-                      ],
-                    ),
-                  ),
-                ),
-              ),
-          ],
-        ),
-      );
-      if (!expanded) return IgnorePointer(child: bar);
-      return MouseRegion(
-        cursor: SystemMouseCursors.click,
-        onEnter: (e) => setState(() => _hoverX = e.localPosition.dx.clamp(0, width)),
-        onHover: (e) => setState(() => _hoverX = e.localPosition.dx.clamp(0, width)),
-        onExit: (_) => setState(() => _hoverX = null),
-        child: Listener(
-          behavior: HitTestBehavior.opaque,
-          onPointerDown: (e) {
-            _dragFraction = width <= 0 ? 0 : (e.localPosition.dx / width).clamp(0.0, 1.0);
-            _drag(true);
-          },
-          onPointerMove: (e) {
-            setState(() => _hoverX = e.localPosition.dx.clamp(0, width));
-            _seekTo(e.localPosition.dx, width);
-          },
-          onPointerUp: (e) {
-            _seekTo(e.localPosition.dx, width);
-            _drag(false);
-          },
-          onPointerCancel: (_) => _drag(false),
-          child: bar,
-        ),
-      );
-    });
-  }
-}
-
-/// Background, cached range (hatched, or a faint band when collapsed),
-/// the played part and the hover line.
-class UoscTimelinePainter extends CustomPainter {
-  final double played;
-  final Rect? Function(Size size) cache;
-  /// What [cache] depends on (repaint when it changes).
-  final Object cacheKey;
-  final double? hoverX;
-  final bool hatched;
-  const UoscTimelinePainter({
-    required this.played,
-    required this.cache,
-    required this.cacheKey,
-    this.hoverX,
-    this.hatched = true,
-  });
-
-  @override
-  void paint(Canvas canvas, Size size) {
-    final all = Offset.zero & size;
-    canvas.drawRect(all, Paint()..color = UoscStyle.bar);
-    final c = cache(size);
-    if (c != null) {
-      if (hatched) {
-        canvas.save();
-        canvas.clipRect(c);
-        final stroke = Paint()
-          ..color = const Color(0x40FFFFFF)
-          ..strokeWidth = 1.5;
-        for (final (a, b) in hatchLines(c)) {
-          canvas.drawLine(a, b, stroke);
-        }
-        canvas.restore();
-      } else {
-        canvas.drawRect(c, Paint()..color = const Color(0x40FFFFFF));
-      }
-    }
-    canvas.drawRect(Rect.fromLTWH(0, 0, size.width * played, size.height), Paint()..color = UoscStyle.fill);
-    final x = hoverX;
-    if (x != null) {
-      canvas.drawRect(Rect.fromLTWH(x - 0.5, 0, 1, size.height), Paint()..color = Colors.white70);
-    }
-  }
-
-  @override
-  bool shouldRepaint(UoscTimelinePainter old) =>
-      old.played != played || old.cacheKey != cacheKey || old.hoverX != hoverX || old.hatched != hatched;
-}

apps/desktop/lib/src/controls/volume.dart

@@ -1,8 +1,11 @@
+import 'dart:async';
+
+import 'package:flutter/foundation.dart' show ValueListenable;
 import 'package:flutter/gestures.dart';
 import 'package:flutter/material.dart';
-import 'package:media_kit/media_kit.dart';
 
 import '../playback/playback_controller.dart' show PlaybackController;
+import '../widgets/app_menu.dart' show AppGlass;
 
 /// The player's top volume (mpv's `volume-max`): past 100 % mpv amplifies.
 const maxVolume = PlaybackController.maxVolume * 1.0;
@@ -10,9 +13,170 @@ const maxVolume = PlaybackController.maxVolume * 1.0;
 /// The part of the volume bar above 100 %.
 const boostColor = Color(0xFFFFB74D);
 
+/// One wheel notch or arrow key.
+const volumeStep = 5.0;
+
 /// [volume] moved by [delta] (wheel, keys), kept within 0..[maxVolume].
 double stepVolume(double volume, double delta) => (volume + delta).clamp(0.0, maxVolume);
 
+/// Turns wheel deltas into volume steps: a mouse notch (a big delta) is
+/// one step, small smooth-scroll deltas add up to one. Mostly horizontal
+/// scrolls (Shift+wheel, sideways pans) are no steps.
+class WheelSteps {
+  // Flutter makes a notch 53 px on Linux, 60 on Windows (3 lines).
+  static const _notch = 50.0;
+  double _sum = 0;
+
+  /// Whether [e] is a vertical scroll (the only kind that steps).
+  static bool vertical(PointerSignalEvent e) =>
+      e is PointerScrollEvent && e.scrollDelta.dy != 0 && e.scrollDelta.dy.abs() > e.scrollDelta.dx.abs();
+
+  /// +1 louder (wheel up), -1 quieter, 0 not a step yet.
+  int take(PointerScrollEvent e) {
+    final dy = e.scrollDelta.dy;
+    if (dy.abs() >= _notch) {
+      _sum = 0;
+      return dy < 0 ? 1 : -1;
+    }
+    if (_sum != 0 && _sum.sign != dy.sign) _sum = 0;
+    _sum += dy;
+    if (_sum.abs() < _notch) return 0;
+    final step = _sum < 0 ? 1 : -1;
+    _sum = 0;
+    return step;
+  }
+
+  /// Claims [e] if it is a vertical scroll that nothing under the mouse
+  /// claimed first (a list, a menu), then calls [onStep] per step.
+  void handle(PointerSignalEvent e, ValueChanged<int> onStep) {
+    if (!vertical(e)) return;
+    GestureBinding.instance.pointerSignalResolver.register(e, (event) {
+      final step = take(event as PointerScrollEvent);
+      if (step != 0) onStep(step);
+    });
+  }
+}
+
+/// The wheel anywhere over [child] steps the volume ([onStep]: +1 / -1),
+/// unless something under the mouse scrolls (it claims the event first)
+/// or [enabled] is off.
+class VolumeWheel extends StatefulWidget {
+  final ValueChanged<int> onStep;
+  final bool enabled;
+  final Widget child;
+  const VolumeWheel({super.key, required this.onStep, this.enabled = true, required this.child});
+
+  @override
+  State<VolumeWheel> createState() => _VolumeWheelState();
+}
+
+class _VolumeWheelState extends State<VolumeWheel> {
+  final _steps = WheelSteps();
+
+  @override
+  Widget build(BuildContext context) => Listener(
+    onPointerSignal: (e) {
+      if (widget.enabled) _steps.handle(e, widget.onStep);
+    },
+    child: widget.child,
+  );
+}
+
+/// Shows [builder] for a second after each [trigger] tick (a wheel or
+/// key volume step), fading in and out; ignores the mouse.
+class VolumeFlash extends StatefulWidget {
+  final ValueListenable<int> trigger;
+  final WidgetBuilder builder;
+  const VolumeFlash({super.key, required this.trigger, required this.builder});
+
+  /// How long the readout stays after the last step.
+  static const hold = Duration(seconds: 1);
+
+  @override
+  State<VolumeFlash> createState() => _VolumeFlashState();
+}
+
+class _VolumeFlashState extends State<VolumeFlash> {
+  bool _on = false;
+  Timer? _timer;
+
+  @override
+  void initState() {
+    super.initState();
+    widget.trigger.addListener(_flash);
+  }
+
+  @override
+  void didUpdateWidget(VolumeFlash old) {
+    super.didUpdateWidget(old);
+    if (old.trigger != widget.trigger) {
+      old.trigger.removeListener(_flash);
+      widget.trigger.addListener(_flash);
+    }
+  }
+
+  @override
+  void dispose() {
+    widget.trigger.removeListener(_flash);
+    _timer?.cancel();
+    super.dispose();
+  }
+
+  void _flash() {
+    if (!mounted) return;
+    setState(() => _on = true);
+    _timer?.cancel();
+    _timer = Timer(VolumeFlash.hold, () {
+      if (mounted) setState(() => _on = false);
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) => IgnorePointer(
+    child: AnimatedOpacity(
+      duration: const Duration(milliseconds: 150),
+      opacity: _on ? 1 : 0,
+      child: _on || _timer != null ? widget.builder(context) : const SizedBox.shrink(),
+    ),
+  );
+}
+
+/// The volume readout for [VolumeFlash] (both skins): a glass pill
+/// (the player's pill look) with the icon, a [VolumeBar] and the
+/// percentage.
+class VolumeReadout extends StatelessWidget {
+  final double volume;
+  const VolumeReadout({super.key, required this.volume});
+
+  @override
+  Widget build(BuildContext context) {
+    final v = volume.clamp(0.0, maxVolume);
+    return AppGlass.pill(
+      key: const ValueKey('volume-readout'),
+      child: Padding(
+        padding: const EdgeInsets.fromLTRB(12, 4, 14, 4),
+        child: Row(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            Icon(volumeIcon(v), size: 20, color: v > 100 ? boostColor : Colors.white),
+            const SizedBox(width: 8),
+            VolumeBar(volume: v, onChanged: (_) {}, width: 96),
+            const SizedBox(width: 10),
+            SizedBox(
+              width: 44,
+              child: Text(
+                '${v.round()} %',
+                textAlign: TextAlign.right,
+                style: const TextStyle(color: Colors.white, fontSize: 13, fontFeatures: [FontFeature.tabularFigures()]),
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}
+
 /// A thin volume track over 0..[maxVolume]: filled up to the volume, the
 /// part above 100 % in [boostColor], a tick at 100 %. Click or drag sets
 /// it.
@@ -61,86 +225,104 @@ class _VolumePainter extends CustomPainter {
       ..strokeCap = StrokeCap.round;
     canvas.drawLine(Offset(0, y), Offset(size.width, y), line..color = trackColor);
     final full = x(100);
-    canvas.drawLine(Offset(full, y - 5), Offset(full, y + 5), Paint()
-      ..color = trackColor
-      ..strokeWidth = 1.5);
+    canvas.drawLine(
+      Offset(full, y - 5),
+      Offset(full, y + 5),
+      Paint()
+        ..color = trackColor
+        ..strokeWidth = 1.5,
+    );
     if (volume > 0) canvas.drawLine(Offset(0, y), Offset(x(volume.clamp(0, 100)), y), line..color = color);
     if (volume > 100) canvas.drawLine(Offset(full, y), Offset(x(volume), y), line..color = boostColor);
     canvas.drawCircle(Offset(x(volume), y), 5, Paint()..color = volume > 100 ? boostColor : color);
   }
 
   @override
-  bool shouldRepaint(_VolumePainter old) =>
-      old.volume != volume || old.color != color || old.trackColor != trackColor;
+  bool shouldRepaint(_VolumePainter old) => old.volume != volume || old.color != color || old.trackColor != trackColor;
 }
 
-/// Volume for the standard bar (instead of media_kit's, which stops at
-/// 100): the icon mutes / unmutes, hovering shows a [VolumeBar], the
-/// wheel steps 5 %.
-class VolumeButton extends StatefulWidget {
-  final Player player;
-  final FocusNode? focusNode;
-  const VolumeButton({super.key, required this.player, this.focusNode});
+/// The speaker icon for [volume].
+IconData volumeIcon(double volume) =>
+    volume <= 0 ? Icons.volume_off_rounded : (volume < 50 ? Icons.volume_down_rounded : Icons.volume_up_rounded);
+
+/// Builds a skin's button for the [VolumeControl].
+typedef VolumeButtonBuilder = Widget Function(
+  BuildContext context,
+  IconData icon,
+  Color? color,
+  String tooltip,
+  VoidCallback onPressed,
+);
+
+/// The bar's volume, in both skins: the skin's speaker button (click
+/// mutes / unmutes), a [VolumeBar] sliding out on hover, the wheel on it
+/// stepping [volumeStep] (claimed, so the player's wheel skips it).
+class VolumeControl extends StatefulWidget {
+  /// 0..[maxVolume].
+  final double volume;
+  final ValueChanged<double> onChanged;
+  final VoidCallback onToggleMute;
+  final VolumeButtonBuilder button;
+  final Color sliderColor;
+  final Color trackColor;
+  final double sliderWidth;
+  const VolumeControl({
+    super.key,
+    required this.volume,
+    required this.onChanged,
+    required this.onToggleMute,
+    required this.button,
+    this.sliderColor = Colors.white,
+    this.trackColor = Colors.white30,
+    this.sliderWidth = 72,
+  });
 
   @override
-  State<VolumeButton> createState() => _VolumeButtonState();
+  State<VolumeControl> createState() => _VolumeControlState();
 }
 
-class _VolumeButtonState extends State<VolumeButton> {
+class _VolumeControlState extends State<VolumeControl> {
+  final _steps = WheelSteps();
   bool _hover = false;
-  double _beforeMute = 100;
 
   @override
   Widget build(BuildContext context) {
-    final player = widget.player;
-    return StreamBuilder<double>(
-      stream: player.stream.volume,
-      initialData: player.state.volume,
-      builder: (context, snap) {
-        final v = snap.data ?? 100;
-        return MouseRegion(
-          onEnter: (_) => setState(() => _hover = true),
-          onExit: (_) => setState(() => _hover = false),
-          child: Listener(
-            onPointerSignal: (e) {
-              if (e is PointerScrollEvent && e.scrollDelta.dy != 0) {
-                player.setVolume(stepVolume(v, e.scrollDelta.dy < 0 ? 5 : -5));
-              }
-            },
-            child: Row(
-              mainAxisSize: MainAxisSize.min,
-              children: [
-                const SizedBox(width: 4),
-                IconButton(
-                  key: const ValueKey('volume-button'),
-                  focusNode: widget.focusNode,
-                  tooltip: 'Volume ${v.round()} %',
-                  iconSize: 22,
-                  color: Colors.white,
-                  onPressed: () {
-                    if (v > 0) {
-                      _beforeMute = v;
-                      player.setVolume(0);
-                    } else {
-                      player.setVolume(_beforeMute <= 0 ? 100 : _beforeMute);
-                    }
-                  },
-                  icon: Icon(v <= 0 ? Icons.volume_off : (v < 50 ? Icons.volume_down : Icons.volume_up)),
-                ),
-                AnimatedSize(
-                  duration: const Duration(milliseconds: 150),
-                  child: _hover
-                      ? Padding(
-                          padding: const EdgeInsets.only(left: 4, right: 12),
-                          child: VolumeBar(volume: v, onChanged: player.setVolume),
-                        )
-                      : const SizedBox.shrink(),
-                ),
-              ],
+    final v = widget.volume;
+    return MouseRegion(
+      onEnter: (_) => setState(() => _hover = true),
+      onExit: (_) => setState(() => _hover = false),
+      child: Listener(
+        onPointerSignal: (e) => _steps.handle(e, (step) => widget.onChanged(stepVolume(v, step * volumeStep))),
+        child: Row(
+          key: const ValueKey('volume-control'),
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            widget.button(
+              context,
+              volumeIcon(v),
+              v > 100 ? boostColor : null,
+              'Volume ${v.round()} %  (scroll, ↑ / ↓)',
+              widget.onToggleMute,
             ),
-          ),
-        );
-      },
+            AnimatedSize(
+              duration: const Duration(milliseconds: 150),
+              child: _hover
+                  ? Padding(
+                      padding: const EdgeInsets.only(left: 4, right: 8),
+                      child: VolumeBar(
+                        key: const ValueKey('volume-bar'),
+                        volume: v,
+                        onChanged: widget.onChanged,
+                        width: widget.sliderWidth,
+                        color: widget.sliderColor,
+                        trackColor: widget.trackColor,
+                      ),
+                    )
+                  : const SizedBox.shrink(),
+            ),
+          ],
+        ),
+      ),
     );
   }
 }

apps/desktop/lib/src/files/thumbnails.dart

@@ -33,15 +33,36 @@ const _timeout = Duration(seconds: 20);
 int _running = 0;
 final _waiting = <Completer<void>>[];
 final _inFlight = <String, Future<Thumbnail?>>{};
+final _players = <Player>{};
+bool _closed = false;
+
+/// App close: no new thumbnails, running ones stop at their next check
+/// and dispose their player. Players still up after [deadline] are
+/// disposed here, so no mpv outlives the engine.
+Future<void> cancelAllThumbnails({
+  Duration deadline = const Duration(milliseconds: 800),
+}) async {
+  _closed = true;
+  try {
+    await Future.wait(_inFlight.values.toList()).timeout(deadline);
+  } catch (_) {}
+  for (final p in _players.toList()) {
+    _players.remove(p);
+    try {
+      await p.dispose().timeout(deadline);
+    } catch (_) {}
+  }
+}
 
 /// The cached or freshly made thumbnail of the video at [path], or null
 /// when it can't be made (not a video, unreadable, timed out, cancelled).
 /// Never throws. [cancelled] is checked while queued and before the
 /// expensive steps: a scrolled-away tile returns null without decoding.
 Future<Thumbnail?> thumbnailFor(String path, {bool Function()? cancelled}) {
+  if (_closed) return Future.value(null);
   final existing = _inFlight[path];
   if (existing != null) return existing;
-  final f = _thumbnailFor(path, cancelled ?? () => false).catchError((
+  final f = _thumbnailFor(path, () => _closed || (cancelled?.call() ?? false)).catchError((
     Object e,
     StackTrace st,
   ) {
@@ -136,6 +157,7 @@ Future<Thumbnail?> _generate(
       bufferSize: 4 << 20,
     ),
   );
+  _players.add(player);
   try {
     final mpv = player.platform as NativePlayer;
     for (final (k, v) in [
@@ -176,6 +198,7 @@ Future<Thumbnail?> _generate(
     }
     return null;
   } finally {
-    await player.dispose();
+    // [cancelAllThumbnails] may have taken it already.
+    if (_players.remove(player)) await player.dispose();
   }
 }

apps/desktop/lib/src/files/ui/file_tiles.dart

@@ -10,9 +10,6 @@ import 'thumb.dart';
 // The Files page's rows and cards: a series header, an episode row (also
 // used for Recent), a loose-video card, and the empty states.
 
-/// Shown on play controls while there is nobody to watch with.
-const offlinePlayHint = 'Join or host to watch';
-
 /// What a play control is doing right now.
 enum PlayState { idle, starting, playing }
 
@@ -28,10 +25,6 @@ String parentName(String path) => baseName(File(path).parent.path);
 /// Cleaned title of a loose video: `Title (2019)`.
 String cleanTitle(ParsedName p) => p.year == null ? p.series : '${p.series} (${p.year})';
 
-/// Disabled with [offlinePlayHint] when [onTap] is null because offline.
-Widget _offlineTip(bool offline, Widget child) =>
-    offline ? Tooltip(message: offlinePlayHint, child: child) : child;
-
 class SeriesHeader extends StatelessWidget {
   final SeriesGroup group;
   final ThumbCache thumbs;
@@ -110,9 +103,8 @@ class FileRow extends StatelessWidget {
   final String? size;
   final PlayState state;
   final ThumbCache thumbs;
-  /// Null disables the row ([offline] adds the reason as a tooltip).
+  /// Null disables the row.
   final VoidCallback? onTap;
-  final bool offline;
   final bool indent;
   final Widget? trailing;
   const FileRow({
@@ -124,7 +116,6 @@ class FileRow extends StatelessWidget {
     required this.state,
     required this.thumbs,
     required this.onTap,
-    required this.offline,
     this.indent = true,
     this.trailing,
   });
@@ -148,62 +139,59 @@ class FileRow extends StatelessWidget {
       builder: (context, t, _) {
         final duration = durationText(t);
         final meta = [?duration, ?size].join(' · ');
-        return _offlineTip(
-          offline,
-          Material(
-            color: playing ? scheme.primary.withValues(alpha: 0.08) : Colors.transparent,
+        return Material(
+          color: playing ? scheme.primary.withValues(alpha: 0.08) : Colors.transparent,
+          borderRadius: BorderRadius.circular(10),
+          child: InkWell(
+            onTap: onTap,
             borderRadius: BorderRadius.circular(10),
-            child: InkWell(
-              onTap: onTap,
-              borderRadius: BorderRadius.circular(10),
-              child: Padding(
-                padding: EdgeInsets.fromLTRB(indent ? 20 : 4, 5, 8, 5),
-                child: Row(
-                  children: [
-                    ClipRRect(
-                      borderRadius: BorderRadius.circular(6),
-                      child: ThumbImage(t, width: 80, height: 45),
-                    ),
-                    const SizedBox(width: 10),
-                    SizedBox(width: 20, child: Center(child: icon)),
-                    const SizedBox(width: 10),
-                    Expanded(
-                      child: Column(
-                        crossAxisAlignment: CrossAxisAlignment.start,
-                        children: [
-                          Row(
-                            children: [
-                              Flexible(
-                                child: Text(
-                                  title,
-                                  maxLines: 1,
-                                  overflow: TextOverflow.ellipsis,
-                                  style: TextStyle(
-                                    fontWeight: FontWeight.w600,
-                                    color: playing ? scheme.primary : null,
-                                  ),
+            child: Padding(
+              padding: EdgeInsets.fromLTRB(indent ? 20 : 4, 5, 8, 5),
+              child: Row(
+                children: [
+                  ClipRRect(
+                    borderRadius: BorderRadius.circular(6),
+                    child: ThumbImage(t, width: 80, height: 45),
+                  ),
+                  const SizedBox(width: 10),
+                  SizedBox(width: 20, child: Center(child: icon)),
+                  const SizedBox(width: 10),
+                  Expanded(
+                    child: Column(
+                      crossAxisAlignment: CrossAxisAlignment.start,
+                      children: [
+                        Row(
+                          children: [
+                            Flexible(
+                              child: Text(
+                                title,
+                                maxLines: 1,
+                                overflow: TextOverflow.ellipsis,
+                                style: TextStyle(
+                                  fontWeight: FontWeight.w600,
+                                  color: playing ? scheme.primary : null,
                                 ),
                               ),
-                              if (playing) ...[
-                                const SizedBox(width: 8),
-                                Pill('now playing', scheme.primary),
-                              ],
+                            ),
+                            if (playing) ...[
+                              const SizedBox(width: 8),
+                              Pill('now playing', scheme.primary),
                             ],
-                          ),
-                          Text(subtitle,
-                              maxLines: 1,
-                              overflow: TextOverflow.ellipsis,
-                              style: TextStyle(color: muted, fontSize: 12)),
-                        ],
-                      ),
+                          ],
+                        ),
+                        Text(subtitle,
+                            maxLines: 1,
+                            overflow: TextOverflow.ellipsis,
+                            style: TextStyle(color: muted, fontSize: 12)),
+                      ],
                     ),
-                    if (meta.isNotEmpty) ...[
-                      const SizedBox(width: 12),
-                      Text(meta, style: TextStyle(color: muted, fontSize: 12)),
-                    ],
-                    ?trailing,
+                  ),
+                  if (meta.isNotEmpty) ...[
+                    const SizedBox(width: 12),
+                    Text(meta, style: TextStyle(color: muted, fontSize: 12)),
                   ],
-                ),
+                  ?trailing,
+                ],
               ),
             ),
           ),
@@ -223,14 +211,12 @@ class VideoCard extends StatelessWidget {
   final PlayState state;
   final ThumbCache thumbs;
   final VoidCallback? onTap;
-  final bool offline;
   const VideoCard({
     super.key,
     required this.video,
     required this.state,
     required this.thumbs,
     required this.onTap,
-    required this.offline,
   });
 
   @override
@@ -242,65 +228,62 @@ class VideoCard extends StatelessWidget {
       path: video.path,
       builder: (context, t, _) {
         final duration = durationText(t);
-        return _offlineTip(
-          offline,
-          InkWell(
-            onTap: onTap,
-            borderRadius: BorderRadius.circular(12),
-            child: Column(
-              crossAxisAlignment: CrossAxisAlignment.start,
-              children: [
-                AspectRatio(
-                  aspectRatio: 16 / 9,
-                  child: Container(
-                    decoration: BoxDecoration(
-                      borderRadius: BorderRadius.circular(12),
-                      border: Border.all(
-                        color: playing ? scheme.primary : Colors.transparent,
-                        width: 2,
-                      ),
+        return InkWell(
+          onTap: onTap,
+          borderRadius: BorderRadius.circular(12),
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              AspectRatio(
+                aspectRatio: 16 / 9,
+                child: Container(
+                  decoration: BoxDecoration(
+                    borderRadius: BorderRadius.circular(12),
+                    border: Border.all(
+                      color: playing ? scheme.primary : Colors.transparent,
+                      width: 2,
                     ),
-                    child: ClipRRect(
-                      borderRadius: BorderRadius.circular(10),
-                      child: Stack(
-                        fit: StackFit.expand,
-                        children: [
-                          ThumbImage(t),
-                          if (duration != null)
-                            Positioned(right: 6, bottom: 6, child: _Badge(duration)),
-                          if (state != PlayState.idle)
-                            Container(
-                              color: Colors.black38,
-                              alignment: Alignment.center,
-                              child: state == PlayState.playing
-                                  ? const Icon(Icons.graphic_eq, color: Colors.white, size: 32)
-                                  : const SizedBox.square(
-                                      dimension: 28,
-                                      child: CircularProgressIndicator(
-                                          strokeWidth: 3, color: Colors.white)),
-                            ),
-                        ],
-                      ),
+                  ),
+                  child: ClipRRect(
+                    borderRadius: BorderRadius.circular(10),
+                    child: Stack(
+                      fit: StackFit.expand,
+                      children: [
+                        ThumbImage(t),
+                        if (duration != null)
+                          Positioned(right: 6, bottom: 6, child: _Badge(duration)),
+                        if (state != PlayState.idle)
+                          Container(
+                            color: Colors.black38,
+                            alignment: Alignment.center,
+                            child: state == PlayState.playing
+                                ? const Icon(Icons.graphic_eq, color: Colors.white, size: 32)
+                                : const SizedBox.square(
+                                    dimension: 28,
+                                    child: CircularProgressIndicator(
+                                        strokeWidth: 3, color: Colors.white)),
+                          ),
+                      ],
                     ),
                   ),
                 ),
-                const SizedBox(height: 6),
-                Flexible(
-                  child: Text(
-                    cleanTitle(video.parsed),
-                    maxLines: 2,
-                    overflow: TextOverflow.ellipsis,
-                    style: TextStyle(
-                      fontWeight: FontWeight.w600,
-                      fontSize: 13,
-                      color: playing ? scheme.primary : null,
-                    ),
+              ),
+              const SizedBox(height: 6),
+              Flexible(
+                child: Text(
+                  cleanTitle(video.parsed),
+                  maxLines: 2,
+                  overflow: TextOverflow.ellipsis,
+                  style: TextStyle(
+                    fontWeight: FontWeight.w600,
+                    fontSize: 13,
+                    color: playing ? scheme.primary : null,
                   ),
                 ),
-                Text(formatSize(video.size),
-                    style: TextStyle(color: scheme.onSurfaceVariant, fontSize: 12)),
-              ],
-            ),
+              ),
+              Text(formatSize(video.size),
+                  style: TextStyle(color: scheme.onSurfaceVariant, fontSize: 12)),
+            ],
           ),
         );
       },

apps/desktop/lib/src/files/ui/files_page.dart

@@ -1,11 +1,13 @@
 import 'dart:async';
 import 'dart:io';
 
-import 'package:file_picker/file_picker.dart';
 import 'package:flutter/material.dart';
 import 'package:signals/signals_flutter.dart';
 
 import '../../shell/motion.dart';
+import '../../platform/ports/folder_access.dart';
+import '../../state/session_state.dart';
+import '../../widgets/app_menu.dart';
 import '../folder_store.dart';
 import '../name_parser.dart';
 import '../scanner.dart';
@@ -31,6 +33,8 @@ String? _lastOpen;
 final _expanded = <String>{};
 final _showRequests = ValueNotifier(0);
 
+FolderAccess get _folders => SessionState.instance.ports.folders;
+
 /// Opens [dir] (null: Recent) in the Files page: now if one is showing,
 /// else when it next opens.
 void showFilesFolder(String? dir) {
@@ -48,16 +52,18 @@ void resetFilesPageSession() {
 }
 
 class FilesPage extends StatefulWidget {
-  /// In a session: false disables playing (browsing still works).
-  final bool online;
+  /// Nobody else watches (offline or solo): no relay notice.
+  final bool solo;
   /// The file will stream from this computer through the server.
   final bool relayed;
   /// Plays [path] in the session; returns an error text, or null.
   final Future<String?> Function(String path) onPlay;
+  /// Adds [path] to Up next (right-click on a video); null: no server.
+  final Future<String?> Function(String path, {bool next})? onAddToQueue;
   final String? nowPlayingPath;
   /// Defaults to [thumbnailFor].
   final ThumbnailLoader? thumbnails;
-  /// Defaults to [scanFolder].
+  /// Defaults to [FolderAccess.scan].
   final Future<FolderScan> Function(String dir)? scan;
   /// Defaults to [FolderStore.instance].
   final FolderStore? store;
@@ -67,9 +73,10 @@ class FilesPage extends StatefulWidget {
 
   const FilesPage({
     super.key,
-    required this.online,
+    this.solo = false,
     required this.relayed,
     required this.onPlay,
+    this.onAddToQueue,
     this.nowPlayingPath,
     this.thumbnails,
     this.scan,
@@ -138,7 +145,7 @@ class _FilesPageState extends State<FilesPage> {
 
   void _shown() => _select(_lastOpen);
 
-  Future<FolderScan> _runScan(String dir) => (widget.scan ?? scanFolder)(dir);
+  Future<FolderScan> _runScan(String dir) => (widget.scan ?? _folders.scan)(dir);
 
   void _select(String? dir) {
     setState(() {
@@ -172,7 +179,7 @@ class _FilesPageState extends State<FilesPage> {
     String? dir;
     try {
       dir = await (widget.pickFolder ??
-          () => FilePicker.getDirectoryPath(dialogTitle: 'Add a folder with videos'))();
+          () => _folders.pickFolder(dialogTitle: 'Add a folder with videos'))();
     } catch (e) {
       _showError('Folder dialog unavailable (${e.runtimeType})');
     }
@@ -192,12 +199,8 @@ class _FilesPageState extends State<FilesPage> {
   }
 
   static Future<String?> _pickVideo() async {
-    final files = await FilePicker.pickFiles(
-      dialogTitle: 'Pick a video',
-      type: FileType.custom,
-      allowedExtensions: videoExtensions.toList(),
-    );
-    return files.isEmpty ? null : files.first.path;
+    final files = await _folders.pickFiles(dialogTitle: 'Pick a video', extensions: videoExtensions.toList());
+    return files.firstOrNull;
   }
 
   void _removeFolder(String dir) {
@@ -207,7 +210,7 @@ class _FilesPageState extends State<FilesPage> {
   }
 
   Future<void> _play(String path) async {
-    if (!widget.online || _starting != null) return;
+    if (_starting != null) return;
     setState(() {
       _starting = path;
       _error = null;
@@ -236,7 +239,36 @@ class _FilesPageState extends State<FilesPage> {
           ? PlayState.playing
           : PlayState.idle;
 
-  VoidCallback? _tapOf(String path) => widget.online ? () => _play(path) : null;
+  VoidCallback _tapOf(String path) => () => _play(path);
+
+  /// Right-click on a video ([context]: its tile): Put it up, Add to
+  /// queue, Play next.
+  Future<void> _menu(BuildContext context, String path) async {
+    final add = widget.onAddToQueue;
+    if (add == null) return;
+    final pick = await showAppMenu<int>(context, items: [
+      AppMenuItem(value: 0, label: widget.solo ? 'Play' : 'Put it up'),
+      const AppMenuItem(value: 1, label: 'Add to queue'),
+      const AppMenuItem(value: 2, label: 'Play next'),
+    ]);
+    if (pick == null || !mounted) return;
+    if (pick == 0) return _play(path);
+    String? error;
+    try {
+      error = await add(path, next: pick == 2);
+    } catch (e) {
+      error = '$e';
+    }
+    if (error != null) _showError(error);
+  }
+
+  /// [child] with the right-click menu (when there is a server).
+  Widget _menuable(String path, Widget child) => widget.onAddToQueue == null
+      ? child
+      : KeyedSubtree(
+          key: ValueKey('menu:$path'),
+          child: Builder(
+              builder: (context) => GestureDetector(onSecondaryTap: () => _menu(context, path), child: child)));
 
   @override
   Widget build(BuildContext context) => LayoutBuilder(
@@ -264,9 +296,7 @@ class _FilesPageState extends State<FilesPage> {
         },
       );
 
-  Widget _browseButton(Widget Function(VoidCallback? onPressed) build) => widget.online
-      ? build(_browse)
-      : Tooltip(message: offlinePlayHint, child: build(null));
+  Widget _browseButton(Widget Function(VoidCallback? onPressed) build) => build(_browse);
 
   Widget _sidebar(BuildContext context, List<String> folders, String? open) {
     final scheme = Theme.of(context).colorScheme;
@@ -345,7 +375,7 @@ class _FilesPageState extends State<FilesPage> {
     final top = <Widget>[
       _header(context, open),
       if (narrow) _chips(folders, open),
-      if (widget.online && widget.relayed) const _RelayNotice(),
+      if (!widget.solo && widget.relayed) const _RelayNotice(),
       AnimatedSize(
         duration: easeTime,
         curve: ease,
@@ -470,15 +500,16 @@ class _FilesPageState extends State<FilesPage> {
         itemCount: recent.length,
         itemBuilder: (context, i) {
           final path = recent[i];
-          return _RecentRow(
-            key: ValueKey(path),
-            path: path,
-            state: _stateOf(path),
-            thumbs: _thumbs,
-            onTap: _tapOf(path),
-            offline: !widget.online,
-            onRemove: () => _store.removeRecent(path),
-          );
+          return _menuable(
+              path,
+              _RecentRow(
+                key: ValueKey(path),
+                path: path,
+                state: _stateOf(path),
+                thumbs: _thumbs,
+                onTap: _tapOf(path),
+                onRemove: () => _store.removeRecent(path),
+              ));
         },
       ),
     ];
@@ -557,7 +588,7 @@ class _FilesPageState extends State<FilesPage> {
       ),
       if (scan.videos.isEmpty)
         SliverToBoxAdapter(
-          child: Directory(dir).existsSync()
+          child: _folders.folderExists(dir)
               ? const FilesEmpty(
                   Icons.search_off,
                   'No videos here',
@@ -585,17 +616,18 @@ class _FilesPageState extends State<FilesPage> {
               onTap: () => setState(() => _expanded.contains(id) ? _expanded.remove(id) : _expanded.add(id)),
             );
           }
-          return FileRow(
-            key: ValueKey(v.path),
-            path: v.path,
-            title: v.parsed.label.isEmpty ? v.parsed.series : v.parsed.label,
-            subtitle: v.name,
-            size: formatSize(v.size),
-            state: _stateOf(v.path),
-            thumbs: _thumbs,
-            onTap: _tapOf(v.path),
-            offline: !widget.online,
-          );
+          return _menuable(
+              v.path,
+              FileRow(
+                key: ValueKey(v.path),
+                path: v.path,
+                title: v.parsed.label.isEmpty ? v.parsed.series : v.parsed.label,
+                subtitle: v.name,
+                size: formatSize(v.size),
+                state: _stateOf(v.path),
+                thumbs: _thumbs,
+                onTap: _tapOf(v.path),
+              ));
         },
       ),
       // Everything else (movies, clips) as a thumbnail grid.
@@ -624,14 +656,15 @@ class _FilesPageState extends State<FilesPage> {
             itemCount: loose.length,
             itemBuilder: (context, i) {
               final v = loose[i];
-              return VideoCard(
-                key: ValueKey(v.path),
-                video: v,
-                state: _stateOf(v.path),
-                thumbs: _thumbs,
-                onTap: _tapOf(v.path),
-                offline: !widget.online,
-              );
+              return _menuable(
+                  v.path,
+                  VideoCard(
+                    key: ValueKey(v.path),
+                    video: v,
+                    state: _stateOf(v.path),
+                    thumbs: _thumbs,
+                    onTap: _tapOf(v.path),
+                  ));
             },
           );
         }),
@@ -647,7 +680,6 @@ class _RecentRow extends StatefulWidget {
   final PlayState state;
   final ThumbCache thumbs;
   final VoidCallback? onTap;
-  final bool offline;
   final VoidCallback onRemove;
   const _RecentRow({
     super.key,
@@ -655,7 +687,6 @@ class _RecentRow extends StatefulWidget {
     required this.state,
     required this.thumbs,
     required this.onTap,
-    required this.offline,
     required this.onRemove,
   });
 
@@ -669,7 +700,7 @@ class _RecentRowState extends State<_RecentRow> {
   @override
   void initState() {
     super.initState();
-    File(widget.path).stat().then((s) {
+    _folders.stat(widget.path).then((s) {
       if (mounted) setState(() => _stat = s);
     }, onError: (Object _) {});
   }
@@ -688,7 +719,6 @@ class _RecentRowState extends State<_RecentRow> {
       state: widget.state,
       thumbs: widget.thumbs,
       onTap: missing ? null : widget.onTap,
-      offline: widget.offline && !missing,
       indent: false,
       trailing: IconButton(
         tooltip: 'Remove from recent',

apps/desktop/lib/src/jellyfin/accounts.dart

@@ -8,8 +8,6 @@ import 'package:hive_ce/hive.dart';
 import 'package:sync_relay_core/core.dart';
 
 import '../screens/home/picked_media.dart';
-import '../screens/home/ui.dart' show appName;
-import '../update/updater.dart' show appVersion;
 
 // Linked Jellyfin servers, one account per ServerId, in their own Hive box.
 //
@@ -196,6 +194,13 @@ class JellyfinAccounts extends ChangeNotifier {
   JellyfinAccount? account(String serverId) =>
       _accounts.where((a) => a.serverId == serverId).firstOrNull;
 
+  /// [itemId]'s page in the web UI of linked server [serverId] ("Open in
+  /// Jellyfin"); null when that server is not linked here.
+  String? webUrlOf(String serverId, String itemId) {
+    final a = account(serverId);
+    return a == null ? null : jellyfinWebUrl(a.baseUrl, itemId, serverId: serverId);
+  }
+
   /// The chosen default, else the first linked server.
   JellyfinAccount? get defaultAccount =>
       (_defaultServerId == null ? null : account(_defaultServerId!)) ?? _accounts.firstOrNull;
@@ -215,7 +220,8 @@ class JellyfinAccounts extends ChangeNotifier {
   String get deviceId => _deviceId;
 
   JellyfinClientInfo get clientInfo => JellyfinClientInfo(
-        client: appName,
+        // The old name on purpose: Jellyfin lists devices under it.
+        client: 'Watch Together',
         device: deviceName ?? _hostname(),
         deviceId: _deviceId.isEmpty ? 'unknown' : _deviceId,
         version: appVersion,
@@ -544,6 +550,17 @@ class JellyfinAccounts extends ChangeNotifier {
   /// Drops cached browse results (refresh button, after a pick).
   void invalidate(String serverId) => _clearMemo(serverId);
 
+  final _watched = StreamController<String>.broadcast();
+
+  /// Server ids whose watched state this app just changed (a stop report):
+  /// their cached lists are gone, and browse views reload.
+  Stream<String> get watched => _watched.stream;
+
+  void watchedChanged(String serverId) {
+    _clearMemo(serverId);
+    _watched.add(serverId);
+  }
+
   @override
   void dispose() {
     _disposed = true;

apps/desktop/lib/src/jellyfin/browse_scope.dart

@@ -6,6 +6,8 @@ import 'package:sync_relay_core/core.dart';
 
 import 'accounts.dart';
 import 'format.dart';
+import '../widgets/app_menu.dart';
+import '../widgets/copy_open.dart';
 
 /// One level of the library browser's back stack.
 sealed class BrowseRoute {
@@ -156,7 +158,14 @@ class BrowseController extends ChangeNotifier {
   final JellyfinAccounts accounts;
   /// Clock for the Continue row's age cut-off (tests pin it).
   final DateTime Function() now;
-  BrowseController(this.accounts, {this.now = DateTime.now});
+  BrowseController(this.accounts, {this.now = DateTime.now}) {
+    // Back from watching: the rows show what was just watched.
+    _watchedSub = accounts.watched.listen((id) {
+      if (!_disposed && id == serverId) dataChanged();
+    });
+  }
+
+  late final StreamSubscription<String> _watchedSub;
 
   String? _serverId;
   List<BrowseRoute> _stack = const [HomeRoute()];
@@ -258,10 +267,19 @@ class BrowseController extends ChangeNotifier {
   @override
   void dispose() {
     _disposed = true;
+    unawaited(_watchedSub.cancel());
     super.dispose();
   }
 }
 
+/// An item's title to copy: an episode with its series ("Show · Name").
+String jellyfinCopyTitle(JellyfinItem item) {
+  final series = item.seriesName;
+  return item.kind == JellyfinItemKind.episode && series != null && series.isNotEmpty
+      ? '$series · ${item.name}'
+      : item.name;
+}
+
 /// What every browser page needs, provided by [JellyfinBrowser].
 class BrowseScope extends InheritedWidget {
   final JellyfinAccounts accounts;
@@ -274,6 +292,9 @@ class BrowseScope extends InheritedWidget {
   final ValueChanged<JellyfinItem> onSelect;
   /// Double-click: put it up (a series: its next episode).
   final ValueChanged<JellyfinItem> onPutUp;
+  /// Adds it to Up next (with next: right after what plays); null: no
+  /// server (the cards' menu then only copies and opens).
+  final void Function(JellyfinItem item, {bool next})? onAddToQueue;
   /// Home shows the library chips itself (the Library tab has them in its
   /// header instead).
   final bool libraryStrip;
@@ -287,6 +308,7 @@ class BrowseScope extends InheritedWidget {
     required this.selectedItemId,
     required this.onSelect,
     required this.onPutUp,
+    this.onAddToQueue,
     this.libraryStrip = true,
     required super.child,
   });
@@ -296,6 +318,33 @@ class BrowseScope extends InheritedWidget {
 
   void onOpen(BrowseRoute route) => controller.open(route);
 
+  /// Right-click on a card ([context]: the card): Put it up, Add to queue,
+  /// Play next (playable, in a server), Copy title, Open in Jellyfin.
+  Future<void> cardMenu(BuildContext context, JellyfinItem item) async {
+    final queue = isSelectable(item) ? onAddToQueue : null;
+    final pick = await showAppMenu<int>(context, items: [
+      if (queue != null) ...const [
+        AppMenuItem(value: 0, label: 'Put it up'),
+        AppMenuItem(value: 1, label: 'Add to queue'),
+        AppMenuItem(value: 2, label: 'Play next'),
+      ],
+      const AppMenuItem(value: 3, label: ReuseText.copyTitle),
+      const AppMenuItem(value: 4, label: ReuseText.openInJellyfin),
+    ]);
+    switch (pick) {
+      case 0:
+        onPutUp(item);
+      case 1:
+        queue!(item);
+      case 2:
+        queue!(item, next: true);
+      case 3:
+        await copyToClipboard(jellyfinCopyTitle(item), done: 'Title copied');
+      case 4:
+        await openLink(jellyfinWebUrl(client.baseUrl, item.id, serverId: account.serverId));
+    }
+  }
+
   /// Cached browse call on this server.
   Future<T> load<T>(String key, Future<T> Function(JellyfinClient c) fn) =>
       accounts.cached(account.serverId, key, () => fn(client));

apps/desktop/lib/src/jellyfin/browser.dart

@@ -30,6 +30,8 @@ class JellyfinBrowser extends StatefulWidget {
   final JellyfinSelection? selected;
   final ValueChanged<JellyfinSelection> onSelect;
   final ValueChanged<JellyfinSelection> onPutUp;
+  /// Right-click on a card: Add to queue / Play next; null: no server.
+  final void Function(JellyfinSelection item, {bool next})? onAddToQueue;
   final VoidCallback? onOpenIntegrations;
   final Duration searchDebounce;
   /// Opens here instead of the remembered location (the series of the
@@ -43,6 +45,7 @@ class JellyfinBrowser extends StatefulWidget {
     required this.accounts,
     required this.onSelect,
     required this.onPutUp,
+    this.onAddToQueue,
     this.controller,
     this.selected,
     this.onOpenIntegrations,
@@ -221,6 +224,10 @@ class _JellyfinBrowserState extends State<JellyfinBrowser> {
       selectedItemId: sel != null && sel.serverId == account.serverId ? sel.itemId : null,
       onSelect: (item) => widget.onSelect(JellyfinSelection(account.serverId, item.id, item)),
       onPutUp: (item) => widget.onPutUp(JellyfinSelection(account.serverId, item.id, item)),
+      onAddToQueue: widget.onAddToQueue == null
+          ? null
+          : (item, {next = false}) =>
+              widget.onAddToQueue!(JellyfinSelection(account.serverId, item.id, item), next: next),
       libraryStrip: widget.libraryStrip,
       child: Focus(
         onKeyEvent: _onKey,

apps/desktop/lib/src/jellyfin/cards.dart

@@ -186,6 +186,7 @@ class _MediaCardState extends State<MediaCard> {
         focusColor: Colors.transparent,
         hoverColor: Colors.transparent,
         onTap: () => _tap(scope),
+        onSecondaryTap: () => scope.cardMenu(context, item),
         onHover: (h) => setState(() => _hover = h),
         onFocusChange: (f) => setState(() => _focus = f),
         child: Column(

apps/desktop/lib/src/jellyfin/details_panel.dart

@@ -2,6 +2,8 @@ import 'package:flutter/material.dart';
 import 'package:sync_relay_core/core.dart';
 
 import '../shell/motion.dart';
+import '../widgets/app_menu.dart';
+import '../widgets/copy_open.dart';
 import 'accounts.dart';
 import 'browse_scope.dart';
 import 'cards.dart' show doubleClickTime, kindIcon;
@@ -32,26 +34,30 @@ typedef _Data = ({
 });
 
 /// The selected card's details, at the right of the library: banner,
-/// title, meta, "Put it up · S1E3" (a disabled Play with [offlineHint]
-/// offline), mark watched / unwatched, remove from Continue, overview and,
+/// title, meta, "Put it up · S1E3" ("Play · S1E3" when watching
+/// [solo]), mark watched / unwatched, remove from Continue, overview and,
 /// for a series or an episode, the episode list (click picks which
 /// episode goes up, double-click puts it up). Reloads when the
 /// [controller]'s data version moves.
 class JellyfinDetailsPanel extends StatefulWidget {
   final BrowseController controller;
   final JellyfinSelection selection;
-  /// Null when online; else why nothing can go up.
-  final String? offlineHint;
+  /// Nobody else watches (offline or solo): the button says Play.
+  final bool solo;
   /// Puts [item] (playable) up; returns an error text, or null when sent.
   final Future<String?> Function(JellyfinSelection item) onPutUp;
+  /// Adds [item] to Up next (with next: right after what plays); null: no
+  /// server, no queue actions.
+  final Future<String?> Function(JellyfinSelection item, {bool next})? onAddToQueue;
   final VoidCallback onClose;
   const JellyfinDetailsPanel({
     super.key,
     required this.controller,
     required this.selection,
     required this.onPutUp,
+    this.onAddToQueue,
     required this.onClose,
-    this.offlineHint,
+    this.solo = false,
   });
 
   @override
@@ -104,7 +110,7 @@ class _JellyfinDetailsPanelState extends State<JellyfinDetailsPanel> {
       _cached('episodes:$seriesId:$seasonId', (c) => c.episodes(seriesId, seasonId: seasonId));
 
   Future<void> _putUp(JellyfinItem target) async {
-    if (_busy || widget.offlineHint != null) return;
+    if (_busy) return;
     setState(() {
       _busy = true;
       _error = null;
@@ -122,6 +128,55 @@ class _JellyfinDetailsPanelState extends State<JellyfinDetailsPanel> {
     });
   }
 
+  Future<void> _queue(JellyfinItem target, {bool next = false}) async {
+    final add = widget.onAddToQueue;
+    if (add == null || _busy) return;
+    setState(() {
+      _busy = true;
+      _error = null;
+    });
+    String? error;
+    try {
+      error = await add(JellyfinSelection(_serverId, target.id, target), next: next);
+    } catch (e) {
+      error = '$e';
+    }
+    if (!mounted) return;
+    setState(() {
+      _busy = false;
+      _error = error;
+    });
+  }
+
+  /// Right-click on an episode ([context]: its row): Put it up, Add to
+  /// queue, Play next (in a server), Copy title, Open in Jellyfin.
+  Future<void> _episodeMenu(BuildContext context, JellyfinItem e) async {
+    final queue = widget.onAddToQueue != null;
+    if (queue) setState(() => _targetId = e.id);
+    final client = _client;
+    final pick = await showAppMenu<int>(context, items: [
+      if (queue) ...[
+        AppMenuItem(value: 0, label: widget.solo ? 'Play' : 'Put it up'),
+        const AppMenuItem(value: 1, label: 'Add to queue'),
+        const AppMenuItem(value: 2, label: 'Play next'),
+      ],
+      const AppMenuItem(value: 3, label: ReuseText.copyTitle),
+      if (client != null) const AppMenuItem(value: 4, label: ReuseText.openInJellyfin),
+    ]);
+    switch (pick) {
+      case 0:
+        await _putUp(e);
+      case 1:
+        await _queue(e);
+      case 2:
+        await _queue(e, next: true);
+      case 3:
+        await copyToClipboard(jellyfinCopyTitle(e), done: 'Title copied');
+      case 4:
+        await openLink(jellyfinWebUrl(client!.baseUrl, e.id, serverId: _serverId));
+    }
+  }
+
   /// Runs a watched-state change, then lets every row reload.
   Future<void> _change(Future<void> Function(JellyfinClient c) action) async {
     final c = _client;
@@ -253,14 +308,8 @@ class _JellyfinDetailsPanelState extends State<JellyfinDetailsPanel> {
       if (shown.communityRating != null) '★ ${shown.communityRating!.toStringAsFixed(1)}',
       if (!isSeries && shown.userData.played) 'Watched',
     ].join(' · ');
-    final hint = widget.offlineHint;
-    final label = playable == null
-        ? (hint == null ? 'Put it up' : 'Play')
-        : hint != null
-            ? 'Play'
-            : isSeries
-                ? 'Put it up · ${playable.episodeLabel ?? playable.name}'
-                : 'Put it up';
+    final verb = widget.solo ? 'Play' : 'Put it up';
+    final label = playable != null && isSeries ? '$verb · ${playable.episodeLabel ?? playable.name}' : verb;
     final inContinue = playable != null &&
         (playable.userData.isResumable || _c.continueKeys.contains(continueKey(playable)));
     final left = playable == null ? null : timeLeft(playable);
@@ -307,12 +356,22 @@ class _JellyfinDetailsPanelState extends State<JellyfinDetailsPanel> {
                 children: [
                   FilledButton.icon(
                     key: const ValueKey('details-put-up'),
-                    onPressed: playable == null || hint != null || _busy ? null : () => _putUp(playable),
+                    onPressed: playable == null || _busy ? null : () => _putUp(playable),
                     icon: _busy
                         ? const SizedBox.square(dimension: 16, child: CircularProgressIndicator(strokeWidth: 2))
                         : const Icon(Icons.play_arrow),
                     label: Text(label, overflow: TextOverflow.ellipsis),
                   ),
+                  if (playable != null && widget.onAddToQueue != null)
+                    GestureDetector(
+                      onSecondaryTap: _busy ? null : () => _queue(playable, next: true),
+                      child: IconButton(
+                        key: const ValueKey('details-add-queue'),
+                        onPressed: _busy ? null : () => _queue(playable),
+                        tooltip: 'Add to queue (right-click: play next)',
+                        icon: const Icon(Icons.playlist_add_rounded),
+                      ),
+                    ),
                   if (playable != null)
                     IconButton(
                       key: const ValueKey('details-watched'),
@@ -334,14 +393,21 @@ class _JellyfinDetailsPanelState extends State<JellyfinDetailsPanel> {
                       onPressed: () => _c.open(SeriesRoute(d.series!, seasonId: seasonId)),
                       icon: const Icon(Icons.open_in_new),
                     ),
+                  if (client != null)
+                    IconButton(
+                      key: const ValueKey('details-open-jellyfin'),
+                      tooltip: ReuseText.openInJellyfin,
+                      onPressed: () => openLink(jellyfinWebUrl(client.baseUrl, shown.id, serverId: _serverId)),
+                      icon: const Icon(Icons.open_in_browser_rounded),
+                    ),
                 ],
               ),
-              if (hint != null || _error != null) ...[
+              if (_error != null) ...[
                 const SizedBox(height: 6),
                 Text(
-                  _error ?? hint!,
+                  _error!,
                   key: const ValueKey('details-hint'),
-                  style: t.bodySmall?.copyWith(color: _error != null ? scheme.error : Colors.grey),
+                  style: t.bodySmall?.copyWith(color: scheme.error),
                 ),
               ],
               if (isSeries && playable != null) ...[
@@ -398,17 +464,13 @@ class _JellyfinDetailsPanelState extends State<JellyfinDetailsPanel> {
       children: [
         const Expanded(child: Text('Episodes', style: TextStyle(fontWeight: FontWeight.w600))),
         if (seasons.length > 1)
-          DropdownButton<String>(
-            key: const ValueKey('details-season'),
-            value: seasonId,
-            isDense: true,
-            underline: const SizedBox.shrink(),
-            borderRadius: BorderRadius.circular(10),
-            items: [
-              for (final s in seasons)
-                DropdownMenuItem(value: s.id, child: Text(s.name, overflow: TextOverflow.ellipsis)),
-            ],
-            onChanged: (id) => setState(() => _seasonId = id),
+          Flexible(
+            child: AppSelect<String?>(
+              key: const ValueKey('details-season'),
+              value: seasonId,
+              items: [for (final s in seasons) (s.id, s.name)],
+              onChanged: (id) => setState(() => _seasonId = id),
+            ),
           ),
       ],
     );
@@ -422,10 +484,12 @@ class _JellyfinDetailsPanelState extends State<JellyfinDetailsPanel> {
     return Material(
       color: isTarget ? scheme.primary.withValues(alpha: 0.10) : Colors.transparent,
       borderRadius: BorderRadius.circular(8),
-      child: InkWell(
+      // The row's own context: its menu opens at the row.
+      child: Builder(builder: (context) => InkWell(
         key: ValueKey('details-episode-${e.id}'),
         borderRadius: BorderRadius.circular(8),
         onTap: () => _tapEpisode(e),
+        onSecondaryTap: () => _episodeMenu(context, e),
         child: Padding(
           padding: const EdgeInsets.symmetric(vertical: 5, horizontal: 4),
           child: Row(
@@ -470,7 +534,7 @@ class _JellyfinDetailsPanelState extends State<JellyfinDetailsPanel> {
             ],
           ),
         ),
-      ),
+      )),
     );
   }
 }

apps/desktop/lib/src/jellyfin/home_page.dart

@@ -3,6 +3,7 @@ import 'package:signals/signals_flutter.dart';
 import 'package:sync_relay_core/core.dart';
 
 import '../state/settings.dart';
+import '../widgets/app_menu.dart';
 import 'browse_scope.dart';
 import 'cards.dart';
 import 'home_rows.dart';
@@ -184,18 +185,18 @@ class _LatestRow extends StatelessWidget {
                   onPressed: () => scope.onOpen(LibraryRoute(view, sort: 'added')),
                   child: const Text('Show all'),
                 ),
-                PopupMenuButton<void>(
+                AppMenuButton<bool>(
                   key: ValueKey('latest-menu-${view.id}'),
                   tooltip: 'Row options',
-                  icon: const Icon(Icons.more_vert, size: 18),
-                  itemBuilder: (context) => [
-                    CheckedPopupMenuItem(
+                  items: () => [
+                    AppMenuItem(
                       key: const ValueKey('hide-rereleases'),
+                      value: !hide,
                       checked: hide,
-                      onTap: () => AppSettings.instance.setHideReReleases(!hide),
-                      child: const Text('Hide re-releases in Latest'),
+                      label: 'Hide re-releases in Latest',
                     ),
                   ],
+                  onSelected: AppSettings.instance.setHideReReleases,
                 ),
               ],
             ),

apps/desktop/lib/src/jellyfin/picker_source.dart

@@ -7,26 +7,31 @@ import 'browser.dart';
 import 'sign_in_panel.dart';
 
 /// The Library's Jellyfin source: the library browser once a server is
-/// linked, else an inline add-server panel.
+/// linked, else [empty] (default: an inline add-server panel).
 class JellyfinPickerSource extends StatefulWidget {
   final JellyfinAccounts accounts;
   final BrowseController? controller;
   final JellyfinSelection? selected;
   final ValueChanged<JellyfinSelection> onSelect;
   final ValueChanged<JellyfinSelection> onPutUp;
+  final void Function(JellyfinSelection item, {bool next})? onAddToQueue;
   final VoidCallback? onOpenIntegrations;
   final BrowseStart? start;
   final bool libraryStrip;
+  /// Shown while no server is linked.
+  final WidgetBuilder? empty;
   const JellyfinPickerSource({
     super.key,
     this.start,
     required this.accounts,
     required this.onSelect,
     required this.onPutUp,
+    this.onAddToQueue,
     this.controller,
     this.selected,
     this.onOpenIntegrations,
     this.libraryStrip = true,
+    this.empty,
   });
 
   @override
@@ -49,6 +54,7 @@ class _JellyfinPickerSourceState extends State<JellyfinPickerSource> {
         if (!a.loaded) {
           return const Center(child: CircularProgressIndicator(strokeWidth: 2));
         }
+        if (a.isEmpty && widget.empty != null) return widget.empty!(context);
         if (a.isEmpty) return _LinkFirst(accounts: a, onOpenIntegrations: widget.onOpenIntegrations);
         return JellyfinBrowser(
           key: const ValueKey('media-jellyfin'),
@@ -57,6 +63,7 @@ class _JellyfinPickerSourceState extends State<JellyfinPickerSource> {
           selected: widget.selected,
           onSelect: widget.onSelect,
           onPutUp: widget.onPutUp,
+          onAddToQueue: widget.onAddToQueue,
           onOpenIntegrations: widget.onOpenIntegrations,
           start: widget.start,
           libraryStrip: widget.libraryStrip,

apps/desktop/lib/src/jellyfin/progress.dart

@@ -1,4 +1,5 @@
 import 'dart:async';
+import 'dart:math' as math;
 
 import 'package:flutter/foundation.dart';
 import 'package:sync_relay_core/core.dart';
@@ -24,6 +25,14 @@ class PlayerSnapshot {
 /// go out one after another; a failure is logged and handed to [onError]
 /// (the session shows one quiet toast) and never touches playback. A 401
 /// calls [onUnauthorized] and ends reporting.
+///
+/// Watched or not is [WatchSession]'s rule, not Jellyfin's position
+/// percentages (see ARCHITECTURE.md "Jellyfin in a session"): an item
+/// played before ([playedBefore]) stays played (re-marked after Playing,
+/// Progress without a position, Stopped without one, then marked played
+/// again); otherwise Progress leaves the position out past
+/// [_noPositionFrom] of the runtime so Jellyfin cannot mark it played on
+/// its own, and Stopped carries what the rule says.
 class JellyfinProgressReporter {
   final JellyfinClient client;
   final String itemId;
@@ -34,20 +43,41 @@ class JellyfinProgressReporter {
   final void Function(Object error)? onError;
   final VoidCallback? onUnauthorized;
 
+  /// What this viewer watched of the item while it was open here.
+  final WatchSession watch;
+
   JellyfinProgressReporter({
     required this.client,
     required this.itemId,
     required this.source,
     required this.playSessionId,
+    bool playedBefore = false,
+    int resumeTicksBefore = 0,
     this.interval = const Duration(seconds: 10),
     this.onError,
     this.onUnauthorized,
+    this.onStopped,
     DateTime Function()? clock,
-  }) : _clock = clock ?? DateTime.now;
+  })  : _clock = clock ?? DateTime.now,
+        _keepPlayed = playedBefore,
+        _runtime = (source.runTimeTicks ?? 0) / jellyfinTicksPerSecond,
+        watch = WatchSession(
+            playedBefore: playedBefore, resumeBefore: resumeTicksBefore / jellyfinTicksPerSecond);
+
+  /// Past this share of the runtime Progress carries no position: Jellyfin
+  /// marks an item played past its "max resume" share (90 % by default).
+  static const _noPositionFrom = 0.85;
+
+  /// After Stopped (and a mark played) went out: the item's watched
+  /// state on the server may differ from what lists show.
+  final void Function()? onStopped;
 
   Future<void> _chain = Future.value();
   bool _playing = false;
   bool _dead = false;
+  bool _keepPlayed;
+  double _runtime;
+  double? _endingStart;
   PlayerSnapshot? _last;
   DateTime? _lastAt;
   DateTime? _lastSentAt;
@@ -55,13 +85,23 @@ class JellyfinProgressReporter {
   /// Between [start] and [stop].
   bool get active => _playing && !_dead;
 
+  /// The item counts as played here (before, or by the rule at a stop).
+  bool get keepsPlayed => _keepPlayed;
+
+  /// The player's duration (used when Jellyfin gave no runtime) and where
+  /// the ending starts (Outro segment / ED chapter), seconds.
+  void timeline({double duration = 0, double? endingStart}) {
+    if ((source.runTimeTicks ?? 0) <= 0 && duration > 0) _runtime = duration;
+    _endingStart = endingStart;
+  }
+
   /// The report body for [s]: ticks, pause, and mpv's aid/sid mapped to
   /// Jellyfin stream indices (-1 = subtitles off).
-  JellyfinPlaybackReport reportFor(PlayerSnapshot s) => JellyfinPlaybackReport(
+  JellyfinPlaybackReport reportFor(PlayerSnapshot s, {bool withPosition = true}) => JellyfinPlaybackReport(
         itemId: itemId,
         mediaSourceId: source.id,
         playSessionId: playSessionId,
-        positionTicks: (s.position * jellyfinTicksPerSecond).round(),
+        positionTicks: withPosition ? _ticks(s.position) : null,
         isPaused: s.paused,
         audioStreamIndex: s.aid == null
             ? null
@@ -71,13 +111,24 @@ class JellyfinProgressReporter {
             : source.jellyfinIndexForMpvTrack(JellyfinStreamType.subtitle, s.sid!),
       );
 
+  static int _ticks(double secs) => (secs * jellyfinTicksPerSecond).round();
+
+  /// Progress may carry the position: not for a played item, not without
+  /// a runtime and not near the end (either would let Jellyfin decide).
+  bool _progressPosition(double position) =>
+      !_keepPlayed && _runtime > 0 && position < _noPositionFrom * _runtime;
+
   /// Playing: once the media is open. Again after [stop] (played to the
-  /// end, then someone seeked back) starts reporting anew.
+  /// end, then someone seeked back) starts reporting anew. A played item
+  /// is marked played again right after (Jellyfin up to 10.11 clears it
+  /// on Playing).
   void start(PlayerSnapshot s) {
     if (_playing || _dead) return;
     _playing = true;
     _mark(s);
+    watch.sample(s.position, playing: !s.paused, at: _clock());
     _send('Playing', () => client.reportPlaybackStart(reportFor(s)));
+    if (_keepPlayed) _send('played', () => client.markPlayed(itemId));
   }
 
   /// Progress when due (see the class doc).
@@ -85,6 +136,7 @@ class JellyfinProgressReporter {
     if (!_playing || _dead) return;
     final last = _last, lastAt = _lastAt, sentAt = _lastSentAt;
     final now = _clock();
+    watch.sample(s.position, playing: !s.paused, at: now);
     var due = force || last == null || lastAt == null || sentAt == null;
     if (!due) {
       final elapsed = now.difference(lastAt).inMilliseconds / 1000;
@@ -99,16 +151,44 @@ class JellyfinProgressReporter {
     _lastAt = now;
     if (!due) return;
     _lastSentAt = now;
-    _send('Progress', () => client.reportPlaybackProgress(reportFor(s)));
+    final report = reportFor(s, withPosition: _progressPosition(s.position));
+    _send('Progress', () => client.reportPlaybackProgress(report));
   }
 
-  /// Stopped (swap, leave, kick, window close, played to the end).
+  /// Stopped (swap, leave, kick, window close, played to the end), as
+  /// [WatchSession.verdict] says: played (or kept played) -> no position,
+  /// then marked played; a peek -> the resume point from before; part way
+  /// -> the position, held under [_noPositionFrom] of the runtime.
   /// Completes when it and everything before it went out.
   Future<void> stop(PlayerSnapshot s) {
     if (!_playing || _dead) return _chain;
     _playing = false;
-    _send('Stopped', () => client.reportPlaybackStopped(reportFor(s)));
-    return _chain;
+    watch.sample(s.position, playing: !s.paused, at: _clock());
+    final v = _keepPlayed
+        ? const WatchVerdict(WatchOutcome.keepPlayed)
+        : watch.verdict(runtime: _runtime, endingStart: _endingStart);
+    debugPrint('jellyfin $itemId: $v (covered ${watch.covered.round()} s of ${_runtime.round()} s)');
+    final int? ticks;
+    switch (v.outcome) {
+      case WatchOutcome.played || WatchOutcome.keepPlayed:
+        _keepPlayed = true;
+        ticks = null;
+      case WatchOutcome.peek:
+        ticks = _ticks(watch.resumeBefore);
+      case WatchOutcome.partial:
+        final at = v.resumeAt ?? s.position;
+        ticks = _ticks(_runtime > 0 ? math.min(at, _noPositionFrom * _runtime) : at);
+    }
+    final report = JellyfinPlaybackReport(
+        itemId: itemId, mediaSourceId: source.id, playSessionId: playSessionId, positionTicks: ticks);
+    _send('Stopped', () => client.reportPlaybackStopped(report));
+    if (ticks == null) {
+      _send('played', () => client.markPlayed(itemId));
+      // Marking played keeps a resume point Progress left (Continue would
+      // still list it, "3 min left"): clear it.
+      _send('resume cleared', () => client.clearResumePosition(itemId));
+    }
+    return _chain = _chain.then((_) => onStopped?.call());
   }
 
   void _mark(PlayerSnapshot s) {

apps/desktop/lib/src/jellyfin/series_page.dart

@@ -375,6 +375,7 @@ class _EpisodeTileState extends State<EpisodeTile> {
         key: ValueKey('episode-${e.id}'),
         focusColor: Colors.transparent,
         onTap: () => _tap(scope),
+        onSecondaryTap: () => scope.cardMenu(context, widget.episode),
         onHover: (h) => setState(() => _hover = h),
         onFocusChange: (f) => setState(() => _focus = f),
         child: Padding(

apps/desktop/lib/src/jellyfin/session_media.dart

@@ -4,6 +4,7 @@ import 'package:flutter/foundation.dart';
 import 'package:sync_relay_core/core.dart';
 
 import '../screens/home/picked_media.dart';
+import '../session/party.dart' show isPresent;
 import 'accounts.dart';
 import 'format.dart';
 
@@ -318,10 +319,11 @@ Future<({EpisodeLink? previous, EpisodeLink? next})> findAdjacentEpisodes(OwnPla
   }
 }
 
-/// When the floating "Next episode" pill appears: at [endingStart] (the
+/// Where the "Next episode" pill's window starts: at [endingStart] (the
 /// ED: Jellyfin Outro segment or ED-titled chapter, see `endingRange`)
 /// when one is known inside [runtime], else the last two minutes of
-/// [runtime] (all of it for shorter media).
+/// [runtime] (all of it for shorter media). The pill shows only while the
+/// controls are up (`PillGate`), so a guessed window costs nothing.
 Duration nextPromptStart(JellyfinItem? item, Duration runtime, {Duration? endingStart}) {
   if (endingStart != null && endingStart > Duration.zero && endingStart < runtime) {
     return endingStart;
@@ -332,13 +334,13 @@ Duration nextPromptStart(JellyfinItem? item, Duration runtime, {Duration? ending
 
 /// Who performs the auto-advance swap, so several counting clients do not
 /// swap twice: the lowest member id among members that play the item with
-/// their own account (`jf[serverId] == true`, not stale). Only what every
+/// their own account (`jf[serverId] == true`, present: `in` or joining). Only what every
 /// client sees in `state` decides (who put the item up is not in it: a
 /// late joiner never saw that swap), so all clients agree.
 String? autoAdvanceSwapper(List<MemberView> members, String serverId) {
   final eligible = [
     for (final m in members)
-      if (!m.stale && m.jf[serverId] == true) m
+      if (isPresent(m) && m.jf[serverId] == true) m
   ];
   if (eligible.isEmpty) return null;
   eligible.sort((a, b) => compareMemberIds(a.id, b.id));

apps/desktop/lib/src/platform/app_log.dart

@@ -0,0 +1,110 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:flutter/foundation.dart';
+import 'package:sync_relay_core/core.dart';
+
+import '../screens/home/ui.dart' show appName, displayVersion;
+import 'ports/app_dirs.dart';
+import '../state/session_state.dart';
+
+// The app's log on disk (<app support>/logs/app-YYYY-MM-DD.log; core's
+// logging.dart writes, rotates and redacts it), debugPrint routed into it,
+// and the "Copy diagnostics" text of Settings → About.
+
+final _appLog = createLogger('app');
+
+/// The logs folder, once [startAppLogging] ran.
+String? appLogDir;
+
+/// Opens the log files in [dirs]' log folder and routes `debugPrint` and
+/// uncaught errors into the log.
+Future<void> startAppLogging(AppDirs dirs) async {
+  try {
+    if (startLogFiles(dirs.logs) != null) appLogDir = dirs.logs;
+  } catch (e) {
+    _appLog.warning('no log files: $e');
+  }
+  // Everything the app prints for diagnosis lands in the file too (the
+  // log's console output replaces the print).
+  debugPrint = (String? message, {int? wrapWidth}) {
+    if (message == null || message.isEmpty) return;
+    final bad = RegExp(r'fail|error|crash|exception', caseSensitive: false).hasMatch(message);
+    bad ? _appLog.warning(message) : _appLog.info(message);
+  };
+  PlatformDispatcher.instance.onError = (error, stack) {
+    _appLog.severe('uncaught: $error', error, stack);
+    return false;
+  };
+  _appLog.info('$appName ${displayVersion()} on ${Platform.operatingSystem} '
+      '${Platform.operatingSystemVersion}, pid $pid, Dart ${Platform.version.split(' ').first}'
+      '${dirs.profile == null ? '' : ', profile ${dirs.profile}'}');
+  for (final line in dirs.migrated) {
+    _appLog.info(line);
+  }
+  final bad = AppDirs.invalidProfile(Platform.environment);
+  if (bad != null) _appLog.warning('$profileEnv="$bad" ignored: use letters, digits, - and _ (at most 32)');
+}
+
+/// The text "Copy diagnostics" gives: versions, then the last [since] of
+/// the app log (its hosted server's records included), already redacted;
+/// with [sessionLog], the server's session log of the same hours after it
+/// (every member's shared lines and the server's, merged).
+Future<String> diagnosticsText({Duration since = const Duration(hours: 6), bool sessionLog = false}) async {
+  final b = StringBuffer()
+    ..writeln('$appName ${displayVersion()}')
+    ..writeln('OS: ${Platform.operatingSystem} ${Platform.operatingSystemVersion}')
+    ..writeln('Dart: ${Platform.version.split(' ').first}');
+  try {
+    final mpv = await SessionState.instance.coordinator.playback.mpvVersion().timeout(const Duration(seconds: 2));
+    b.writeln('mpv: ${mpv ?? 'no player yet'}');
+  } catch (_) {
+    b.writeln('mpv: unknown');
+  }
+  try {
+    final y = await SessionState.instance.ports.links.ytDlp.timeout(const Duration(seconds: 2));
+    final cookies = y.cookies.read(count: false);
+    b.writeln('yt-dlp: ${y.version ?? 'not ready'}${y.lastError == null ? '' : ' (${y.lastError})'}, '
+        'cookies: ${cookies == null ? 'none' : 'set'}');
+  } catch (_) {
+    b.writeln('yt-dlp: unknown');
+  }
+  final files = logFiles;
+  b.writeln('Log: ${files?.currentPath ?? 'none (console only)'}');
+  b.writeln('--- last ${since.inHours} h of the log ---');
+  b.write(files?.recent(since) ?? '');
+  if (sessionLog) {
+    final server = await SessionState.instance.coordinator.sessionLog(hours: since.inHours);
+    b
+      ..writeln()
+      ..writeln("--- last ${since.inHours} h of the server's session log ---")
+      ..write(server ?? "(none: the server keeps no session log, or it couldn't be reached)");
+  }
+  return redactLog(b.toString());
+}
+
+/// Saves [text] next to the logs as `diagnostics-<time>.txt`; its path,
+/// or null when it could not be written.
+Future<String?> saveDiagnostics(String text) async {
+  final dir = appLogDir;
+  if (dir == null) return null;
+  final t = DateTime.now();
+  String two(int n) => n.toString().padLeft(2, '0');
+  final path = '$dir${Platform.pathSeparator}diagnostics-${t.year}${two(t.month)}${two(t.day)}-'
+      '${two(t.hour)}${two(t.minute)}${two(t.second)}.txt';
+  try {
+    // Older ones go after the log files' week.
+    for (final e in Directory(dir).listSync()) {
+      if (e is File &&
+          e.uri.pathSegments.last.startsWith('diagnostics-') &&
+          t.difference(e.statSync().modified) > const Duration(days: 7)) {
+        e.deleteSync();
+      }
+    }
+    await File(path).writeAsString(text);
+    return path;
+  } catch (e) {
+    _appLog.warning('cannot save diagnostics: $e');
+    return null;
+  }
+}

apps/desktop/lib/src/platform/app_shutdown.dart

@@ -0,0 +1,71 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:flutter/foundation.dart';
+
+import '../files/thumbnails.dart';
+import '../state/session_state.dart';
+
+// The one way out of the app (close button, Alt+F4, Update and restart).
+// Order matters: every mpv player goes before the engine does (a live one
+// calls a dead Dart callback), then the network goodbye, then the window
+// closes through the platform's normal path so the engine is torn down
+// inside the message loop. The runners end the process right after
+// (`linux/runner/main.cc`, `windows/runner/main.cpp`).
+
+bool _shuttingDown = false;
+
+/// True once [shutDownApp] started.
+bool get shuttingDown => _shuttingDown;
+
+/// Hides the window, releases every player and the sound device, leaves
+/// (the `bye` goes out first, so others see "left" at once; a hosted
+/// server stops), runs [beforeQuit], then closes the window. [restart]
+/// (Update and restart) leaves without the `bye`: the member stays
+/// `gone`, and the restarted app, same client id, takes it back within
+/// the grace. Every step is bounded; a second call does nothing.
+Future<void> shutDownApp({Future<void> Function()? beforeQuit, bool restart = false}) async {
+  if (_shuttingDown) return;
+  _shuttingDown = true;
+  final session = SessionState.instance;
+  final shell = session.ports.shell;
+  final total = Stopwatch()..start();
+  await _step('window save', shell.saveWindow(), const Duration(milliseconds: 500));
+  await _step('hide', shell.hide(), const Duration(milliseconds: 500));
+  await Future.wait([
+    _step('players', session.coordinator.releasePlayers(), const Duration(seconds: 3)),
+    _step('thumbnails', cancelAllThumbnails(), const Duration(milliseconds: 1500)),
+    _step('sounds', session.sfx.dispose(), const Duration(milliseconds: 500)),
+  ]);
+  // Windows: media_kit_video frees a player's video output on a thread of
+  // its own after dispose returns; it must be done before the engine
+  // stops, or the plugin's teardown waits on it for good.
+  if (Platform.isWindows) await Future.delayed(const Duration(milliseconds: 300));
+  // Jellyfin stop report, last diagnostics, the bye (flushed), then the
+  // hosted server: 3 s in all.
+  await _step('leave', session.leave(bye: !restart), const Duration(milliseconds: 2500));
+  await _step('server stop', session.stopServer(), const Duration(milliseconds: 500));
+  if (beforeQuit != null) await _step('before quit', beforeQuit(), const Duration(seconds: 3));
+  debugPrint('close: ready to quit after ${total.elapsedMilliseconds} ms');
+  await shell.quit();
+  // The engine stops with the window, so this only fires when the close
+  // did not go through. A kill, not exit(): no exit handlers (NVIDIA's
+  // EGL one segfaults, Windows DLL detach can hang).
+  Timer(const Duration(seconds: 3), () {
+    debugPrint('close: the window did not close; ending the process');
+    Process.killPid(pid, ProcessSignal.sigkill);
+  });
+}
+
+Future<void> _step(String what, Future<void>? f, Duration limit) async {
+  if (f == null) return;
+  final sw = Stopwatch()..start();
+  try {
+    await f.timeout(limit);
+  } on TimeoutException {
+    debugPrint('close: $what did not finish in ${limit.inMilliseconds} ms');
+  } catch (e) {
+    debugPrint('close: $what failed: $e');
+  }
+  if (sw.elapsedMilliseconds > 200) debugPrint('close: $what took ${sw.elapsedMilliseconds} ms');
+}

apps/desktop/lib/src/platform/audio/sound_engine.dart

@@ -0,0 +1,133 @@
+import 'dart:async';
+import 'dart:typed_data';
+
+import 'package:flutter_soloud/flutter_soloud.dart';
+import 'package:sync_relay_core/core.dart';
+
+final _log = createLogger('sound');
+
+/// What [SoundEngine] needs from an audio library: [SoLoudBackend] in the
+/// app, a fake in tests. A sound handle is whatever [load] returns.
+abstract class AudioBackend {
+  Future<void> init();
+  /// Decodes [wav] (a whole WAV file) into memory under [name].
+  Future<Object> load(String name, Uint8List wav);
+  /// Starts one voice of [sound] at [volume] (linear gain, 0..1); voices
+  /// overlap.
+  void play(Object sound, double volume);
+  Future<void> unload(Object sound);
+  Future<void> deinit();
+}
+
+/// flutter_soloud (SoLoud mixing into miniaudio's output device).
+class SoLoudBackend implements AudioBackend {
+  SoLoud get _s => SoLoud.instance;
+
+  @override
+  Future<void> init() => _s.init();
+
+  @override
+  Future<Object> load(String name, Uint8List wav) => _s.loadMem(name, wav);
+
+  @override
+  void play(Object sound, double volume) => _s.play(sound as AudioSource, volume: volume);
+
+  @override
+  Future<void> unload(Object sound) => _s.disposeSource(sound as AudioSource);
+
+  @override
+  Future<void> deinit() => _s.deinitAsync();
+}
+
+/// The app's short in-memory sounds. The audio device opens on [warmUp] or
+/// the first [play]; if it can't (no device, a broken driver) the engine
+/// logs once and every play is silently dropped. Each sound is loaded once
+/// per slot from the WAV bytes its renderer gives; a new key in a slot
+/// replaces (and frees) what the slot held.
+class SoundEngine {
+  final AudioBackend _backend;
+  SoundEngine({AudioBackend? backend}) : _backend = backend ?? SoLoudBackend();
+
+  Future<bool>? _ready;
+  var _disposed = false;
+  /// Per slot: the loaded key and its sound (null: failed to load).
+  final Map<String, (String, Future<Object?>)> _slots = {};
+  /// Load names are unique: SoLoud hands back the old sound for a name it
+  /// already holds, which would defeat a re-render.
+  var _loads = 0;
+
+  /// Opens the audio device now, so the first sound has no wait.
+  Future<bool> warmUp() => _ready ??= _init();
+
+  Future<bool> _init() async {
+    if (_disposed) return false;
+    try {
+      await _backend.init();
+      return true;
+    } catch (e) {
+      _log.warning('no sounds: audio init failed: $e');
+      return false;
+    }
+  }
+
+  /// Plays the sound of [slot] at [volume] (linear gain). [key] names what
+  /// [wav] renders: the same key reuses the loaded sound; another key, or
+  /// [fresh], renders and loads it again.
+  Future<void> play(String slot, String key, Future<Uint8List> Function() wav,
+      {required double volume, bool fresh = false}) async {
+    if (_disposed || volume <= 0) return;
+    if (!await warmUp() || _disposed) return;
+    var held = _slots[slot];
+    if (held == null || held.$1 != key || fresh) {
+      if (held != null) unawaited(_unload(held.$2));
+      held = (key, _load(key, wav));
+      _slots[slot] = held;
+    }
+    final sound = await held.$2;
+    if (sound == null) {
+      // Retry on the next play.
+      if (identical(_slots[slot], held)) _slots.remove(slot);
+      return;
+    }
+    if (_disposed || !identical(_slots[slot], held)) return;
+    try {
+      _backend.play(sound, volume.clamp(0.0, 1.0));
+    } catch (e) {
+      _log.warning('sound $key: $e');
+    }
+  }
+
+  Future<Object?> _load(String key, Future<Uint8List> Function() wav) async {
+    try {
+      return await _backend.load('$key#${_loads++}', await wav());
+    } catch (e) {
+      _log.warning('sound $key: $e');
+      return null;
+    }
+  }
+
+  Future<void> _unload(Future<Object?> sound) async {
+    try {
+      final s = await sound;
+      if (s != null && !_disposed) await _backend.unload(s);
+    } catch (e) {
+      _log.fine('unload: $e');
+    }
+  }
+
+  /// Frees every sound and closes the audio device. Plays after it are
+  /// dropped.
+  Future<void> dispose() async {
+    if (_disposed) return;
+    _disposed = true;
+    _slots.clear();
+    final ready = _ready;
+    if (ready == null || !await ready) return;
+    try {
+      // Deinit frees the loaded sounds with the engine.
+      await _backend.deinit();
+    } catch (e) {
+      _log.warning('audio deinit: $e');
+    }
+  }
+}

apps/desktop/lib/src/platform/data_migration.dart

@@ -0,0 +1,116 @@
+import 'dart:convert';
+import 'dart:io';
+
+// First start of the renamed app (Starsync, app id dev.foxyz.starsync):
+// copy what the old names left, never move, so a 1.2.x install keeps
+// working next to it. Runs once (the marker file), then never again.
+
+/// Written into the new support folder once the migration ran (whether or
+/// not anything was found): `migratedFrom` (the old support folder or
+/// null), `hiveFrom` (the folder the boxes came from or null), `boxes`,
+/// `files`.
+const migrationMarker = 'migration.json';
+
+/// The Hive boxes the app opens, by name (settings, connect form, Files,
+/// Jellyfin sign-ins, track choices). Only these leave the documents
+/// folder, which other apps' boxes share.
+const appHiveBoxes = ['settings', 'connect_form', 'files', 'jellyfin', 'track_prefs'];
+
+/// Support folders of the old names for the new [support] folder, the
+/// most likely first. Linux: `$XDG_DATA_HOME/moe.senkochan.watch_together`
+/// (the GTK application id up to 1.2.x), then `watch_together` (the
+/// executable name path_provider falls back to). Windows:
+/// `%APPDATA%\com.example\watch_together` (company and product name of
+/// the exe up to 1.2.x).
+List<String> legacySupportDirs(String support, {bool? windows}) {
+  final win = windows ?? Platform.isWindows;
+  final sep = win ? r'\' : '/';
+  String parent(String p) {
+    final norm = p.endsWith(sep) ? p.substring(0, p.length - 1) : p;
+    final i = norm.lastIndexOf(sep);
+    return i <= 0 ? norm : norm.substring(0, i);
+  }
+
+  if (win) return ['${parent(parent(support))}${sep}com.example${sep}watch_together'];
+  final share = parent(support);
+  return ['$share${sep}moe.senkochan.watch_together', '$share${sep}watch_together'];
+}
+
+/// Copies the first existing [oldSupport] folder into [support] and the
+/// [appHiveBoxes] (`.hive` and `.lock`) from [documents] into [hive],
+/// skipping anything already there; the originals stay. Once per support
+/// folder ([migrationMarker]). Returns one log line per thing copied
+/// (paths and counts, never contents); empty when it ran before.
+Future<List<String>> migrateLegacyData(
+    {required String support, required String hive, required List<String> oldSupport, String? documents}) async {
+  final sep = Platform.pathSeparator;
+  final marker = File('$support$sep$migrationMarker');
+  if (marker.existsSync()) return const [];
+  final lines = <String>[];
+  String? from;
+  var files = 0;
+  for (final old in oldSupport) {
+    final dir = Directory(old);
+    if (!dir.existsSync() || _same(old, support)) continue;
+    files = await _copyTree(dir, Directory(support));
+    from = old;
+    lines.add('migration: copied $files files from $old to $support');
+    break;
+  }
+  final boxes = <String>[];
+  if (documents != null && Directory(documents).existsSync() && !_same(documents, hive)) {
+    await Directory(hive).create(recursive: true);
+    for (final box in appHiveBoxes) {
+      for (final ext in const ['hive', 'lock']) {
+        final src = File('$documents$sep$box.$ext');
+        final dst = File('$hive$sep$box.$ext');
+        if (!src.existsSync() || dst.existsSync()) continue;
+        await src.copy(dst.path);
+        if (ext == 'hive') boxes.add(box);
+      }
+    }
+    if (boxes.isNotEmpty) {
+      lines.add('migration: copied ${boxes.length} Hive boxes (${boxes.join(', ')}) from $documents to $hive');
+    }
+  }
+  if (lines.isEmpty) lines.add('migration: no data from before the rename');
+  await Directory(support).create(recursive: true);
+  await marker.writeAsString(jsonEncode({
+    'migratedFrom': from,
+    'hiveFrom': boxes.isEmpty ? null : documents,
+    'boxes': boxes,
+    'files': files,
+  }));
+  return lines;
+}
+
+bool _same(String a, String b) {
+  try {
+    return FileSystemEntity.identicalSync(a, b);
+  } catch (_) {
+    return false;
+  }
+}
+
+// Files (File.copy keeps the mode on POSIX: cookies.txt stays 0600, yt-dlp
+// executable) and symlinks as they are; existing targets win.
+Future<int> _copyTree(Directory from, Directory to) async {
+  var n = 0;
+  await to.create(recursive: true);
+  await for (final e in from.list(recursive: true, followLinks: false)) {
+    final target = '${to.path}${e.path.substring(from.path.length)}';
+    if (e is Directory) {
+      await Directory(target).create(recursive: true);
+    } else if (await FileSystemEntity.type(target, followLinks: false) != FileSystemEntityType.notFound) {
+      continue;
+    } else if (e is Link) {
+      await Directory(File(target).parent.path).create(recursive: true);
+      await Link(target).create(await e.target());
+    } else if (e is File) {
+      await Directory(File(target).parent.path).create(recursive: true);
+      await e.copy(target);
+      n++;
+    }
+  }
+  return n;
+}

apps/desktop/lib/src/platform/desktop/attention.dart

@@ -0,0 +1,19 @@
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+
+/// The runner's window channel (linux/runner/my_application.cc,
+/// windows/runner/flutter_window.cpp).
+const _window = MethodChannel('starsync/window');
+
+/// Asks the desktop to point at the app's window (taskbar flash, urgency
+/// hint) when it is not focused; nothing when it is. The runner clears it
+/// once the window gets focus. Quietly nothing where the runner lacks it.
+Future<void> requestWindowAttention() async {
+  try {
+    await _window.invokeMethod<void>('attention');
+  } on MissingPluginException {
+    // Tests, other platforms.
+  } catch (e) {
+    debugPrint('window attention: $e');
+  }
+}

apps/desktop/lib/src/platform/desktop/desktop_app_dirs.dart

@@ -0,0 +1,35 @@
+import 'dart:io';
+
+import 'package:path_provider/path_provider.dart';
+
+import '../data_migration.dart';
+import '../ports/app_dirs.dart';
+
+/// The desktop's [AppDirsPort]: the app support folder from path_provider
+/// (Linux `$XDG_DATA_HOME/dev.foxyz.starsync`, Windows
+/// `%APPDATA%\foxyz\Starsync`); on the first start it copies the data of
+/// the old names in ([migrateLegacyData]). Needs Flutter's binding.
+class DesktopAppDirs implements AppDirsPort {
+  const DesktopAppDirs();
+
+  @override
+  Future<AppDirs> resolve() async {
+    final support = (await getApplicationSupportDirectory()).path;
+    final base = AppDirs.fromEnv(support: support, env: const {});
+    List<String> migrated;
+    try {
+      String? documents;
+      try {
+        // Where Hive.initFlutter() kept the boxes up to 1.2.x.
+        documents = (await getApplicationDocumentsDirectory()).path;
+      } catch (_) {}
+      migrated = await migrateLegacyData(
+          support: support, hive: base.hive, oldSupport: legacySupportDirs(support), documents: documents);
+    } catch (e) {
+      migrated = ['migration failed: $e'];
+    }
+    final dirs = AppDirs.fromEnv(support: support, env: Platform.environment, migrated: migrated);
+    await Directory(dirs.hive).create(recursive: true);
+    return dirs;
+  }
+}

apps/desktop/lib/src/platform/desktop/desktop_folders.dart

@@ -0,0 +1,40 @@
+import 'dart:io';
+
+import 'package:file_picker/file_picker.dart';
+
+import '../../files/scanner.dart';
+import '../ports/folder_access.dart';
+import '../ports/url_opener.dart';
+
+/// [FolderAccess] on a desktop file system: file_picker's dialogs, the
+/// [scanFolder] walk, the file manager through [UrlOpener].
+class DesktopFolders implements FolderAccess {
+  final UrlOpener urls;
+  const DesktopFolders(this.urls);
+
+  @override
+  Future<String?> pickFolder({required String dialogTitle}) => FilePicker.getDirectoryPath(dialogTitle: dialogTitle);
+
+  @override
+  Future<List<String>> pickFiles({required String dialogTitle, required List<String> extensions}) async {
+    final files = await FilePicker.pickFiles(
+      dialogTitle: dialogTitle,
+      type: FileType.custom,
+      allowedExtensions: extensions,
+    );
+    return [for (final f in files) ?f.path];
+  }
+
+  @override
+  Future<FolderScan> scan(String dir) => scanFolder(dir);
+
+  @override
+  bool folderExists(String dir) => Directory(dir).existsSync();
+
+  @override
+  Future<FileStat> stat(String path) => File(path).stat();
+
+  // The file manager opens a folder path the way a browser opens a link.
+  @override
+  Future<bool> reveal(String dir) => urls.open(Uri.directory(dir).toString());
+}

apps/desktop/lib/src/platform/desktop/desktop_notifications.dart

@@ -0,0 +1,100 @@
+import 'dart:io';
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter_local_notifications/flutter_local_notifications.dart';
+
+import '../desktop_entry.dart' show appId;
+import '../ports/system_notifications.dart';
+
+/// [SystemNotifications] on the desktop, through flutter_local_notifications'
+/// platform plugins (used directly, not through its facade, so the platform
+/// is picked by the OS and not by Flutter's target platform):
+/// - Linux: `org.freedesktop.Notifications` over D-Bus (pure Dart), with the
+///   app's icon (the bundled PNG, else the launcher entry's icon by name);
+///   a click is the notification's default action.
+/// - Windows: toast notifications (WinRT), the app's name and icon, a click
+///   activates the app while it runs (an unpackaged app has no history).
+/// Silent: the app plays its own sound for the same notice. Anything that
+/// fails (no notification daemon, no session bus) is logged and dropped.
+class DesktopNotifications implements SystemNotifications {
+  DesktopNotifications({this.appName = 'Starsync'});
+
+  final String appName;
+  void Function(String payload)? _onClick;
+  Future<bool>? _ready;
+  LinuxFlutterLocalNotificationsPlugin? _linux;
+  FlutterLocalNotificationsWindows? _windows;
+  // Tag -> id, so a notification with the same tag replaces the last one.
+  final _ids = <String, int>{};
+  int _next = 1;
+
+  @override
+  set onClick(void Function(String payload)? handler) => _onClick = handler;
+
+  void _clicked(NotificationResponse r) => _onClick?.call(r.payload ?? '');
+
+  /// The bundled 256 px icon next to the executable (a release or a
+  /// `flutter run` build), else the icon the launcher entry installed.
+  static LinuxNotificationIcon _linuxIcon() {
+    final exe = File(Platform.resolvedExecutable).parent.path;
+    final png = File('$exe/data/flutter_assets/assets/icon/icon_256.png');
+    return png.existsSync() ? FilePathLinuxIcon(png.path) : ThemeLinuxIcon(appId);
+  }
+
+  Future<bool> _init() => _ready ??= () async {
+        try {
+          if (Platform.isLinux) {
+            final p = _linux = LinuxFlutterLocalNotificationsPlugin();
+            return await p.initialize(
+                  settings: LinuxInitializationSettings(defaultActionName: 'Open', defaultIcon: _linuxIcon()),
+                  onDidReceiveNotificationResponse: _clicked,
+                ) ??
+                false;
+          }
+          if (Platform.isWindows) {
+            final exe = File(Platform.resolvedExecutable).parent.path;
+            final icon = File('$exe/data/flutter_assets/assets/icon/icon_256.png');
+            final p = _windows = FlutterLocalNotificationsWindows();
+            return await p.initialize(
+              settings: WindowsInitializationSettings(
+                appName: appName,
+                appUserModelId: 'Foxyz.Starsync',
+                guid: '6c0f4b4e-3e8a-4b8e-9d0c-5a7f2b1e9c31',
+                iconPath: icon.existsSync() ? icon.path : null,
+              ),
+              onDidReceiveNotificationResponse: _clicked,
+            );
+          }
+        } catch (e) {
+          debugPrint('system notifications unavailable: $e');
+        }
+        return false;
+      }();
+
+  @override
+  Future<void> show({required String title, required String body, String tag = '', String payload = ''}) async {
+    if (!await _init()) return;
+    final id = tag.isEmpty ? _next++ : _ids[tag] ??= _next++;
+    try {
+      if (_linux case final p?) {
+        await p.show(
+          id: id,
+          title: title,
+          body: body,
+          payload: payload,
+          notificationDetails: const LinuxNotificationDetails(suppressSound: true),
+        );
+      } else if (_windows case final p?) {
+        await p.show(
+          id: id,
+          title: title,
+          body: body,
+          payload: payload,
+          notificationDetails: WindowsNotificationDetails(audio: WindowsNotificationAudio.silent()),
+        );
+      }
+    } catch (e) {
+      debugPrint('system notification failed: $e');
+    }
+  }
+}

apps/desktop/lib/src/platform/desktop/desktop_ports.dart

@@ -0,0 +1,18 @@
+import '../../playback/yt_dlp_app.dart';
+import '../ports/ports.dart';
+import 'desktop_folders.dart';
+import 'desktop_notifications.dart';
+import 'desktop_shell.dart';
+import 'desktop_urls.dart';
+
+/// The desktop's [Ports].
+Ports desktopPorts() {
+  const urls = DesktopUrls();
+  return Ports(
+    shell: DesktopShell(),
+    urls: urls,
+    folders: const DesktopFolders(urls),
+    links: AppYtDlp.instance,
+    notifications: DesktopNotifications(),
+  );
+}

apps/desktop/lib/src/platform/desktop/desktop_shell.dart

@@ -0,0 +1,178 @@
+import 'dart:async';
+
+import 'package:flutter/widgets.dart';
+import 'package:fox_utils/fox_utils.dart' show ClipboardX, DesktopDropX, DropTarget;
+import 'package:hive_ce_flutter/hive_flutter.dart';
+import 'package:window_manager/window_manager.dart';
+
+import '../../state/settings.dart' show settingsBoxName;
+import 'attention.dart';
+import '../ports/shell_port.dart';
+import 'window_memory.dart';
+
+/// [ShellPort] on Linux and Windows: window_manager for the window,
+/// [WindowMemory] for its size and place, the runner's channel for
+/// attention, fox_utils for drops and the clipboard.
+class DesktopShell implements ShellPort {
+  WindowMemory? _memory;
+
+  @override
+  Future<void> start({required String title, required Future<void> Function() onCloseRequest}) async {
+    await windowManager.ensureInitialized();
+    await windowManager.setPreventClose(true);
+    final memory = _memory = WindowMemory(Hive.isBoxOpen(settingsBoxName) ? Hive.box(settingsBoxName) : null);
+    windowManager.addListener(_CloseGuard(onCloseRequest));
+    final windowOptions = WindowOptions(
+      size: memory.size,
+      minimumSize: const Size(160, 90),
+      center: !memory.hasPosition,
+      backgroundColor: const Color(0xFF000000),
+      titleBarStyle: TitleBarStyle.hidden,
+      title: title,
+    );
+    unawaited(windowManager.waitUntilReadyToShow(windowOptions, () async {
+      await memory.restore();
+      await windowManager.show();
+      await windowManager.focus();
+    }));
+  }
+
+  @override
+  Future<void> setFullScreen(bool on) => windowManager.setFullScreen(on);
+  @override
+  Future<void> minimize() => windowManager.minimize();
+  @override
+  Future<bool> isMaximized() => windowManager.isMaximized();
+  @override
+  Future<void> maximize() => windowManager.maximize();
+  @override
+  Future<void> unmaximize() => windowManager.unmaximize();
+
+  @override
+  void Function() watchMaximized(void Function(bool maximized) onChange) {
+    final l = _MaximizeWatch(onChange);
+    windowManager.addListener(l);
+    return () => windowManager.removeListener(l);
+  }
+
+  final _activity = <void Function(WindowActivity)>{};
+
+  @override
+  void Function() watchActivity(void Function(WindowActivity activity) onChange) {
+    final l = _ActivityWatch(onChange);
+    _activity.add(onChange);
+    windowManager.addListener(l);
+    return () {
+      _activity.remove(onChange);
+      windowManager.removeListener(l);
+    };
+  }
+
+  @override
+  Future<void> startDragging() => windowManager.startDragging();
+
+  @override
+  Future<void> requestClose() => windowManager.close();
+
+  @override
+  Future<void> saveWindow() async => _memory?.save();
+
+  @override
+  Future<void> hide() async {
+    // window_manager has no hide event: tell the watchers here.
+    for (final f in [..._activity]) {
+      f(WindowActivity.hidden);
+    }
+    await windowManager.hide();
+  }
+
+  @override
+  Future<void> quit() async {
+    try {
+      await windowManager.setPreventClose(false);
+      await windowManager.close();
+    } catch (e) {
+      debugPrint('window close failed: $e');
+      await windowManager.destroy();
+    }
+  }
+
+  @override
+  Future<void> focus() async {
+    try {
+      if (await windowManager.isMinimized()) await windowManager.restore();
+      if (!await windowManager.isVisible()) await windowManager.show();
+      await windowManager.focus();
+    } catch (e) {
+      debugPrint('window focus failed: $e');
+    }
+  }
+
+  @override
+  Future<void> requestAttention() => requestWindowAttention();
+
+  @override
+  Future<Paste> readPaste() async {
+    var files = const <String>[];
+    String? text;
+    try {
+      files = await ClipboardX.readFiles();
+    } catch (_) {}
+    if (files.isEmpty) {
+      try {
+        text = await ClipboardX.readText();
+      } catch (_) {}
+    }
+    return (files: files, text: text);
+  }
+
+  @override
+  Widget dropTarget({
+    Key? key,
+    bool enable = true,
+    VoidCallback? onEnter,
+    VoidCallback? onExit,
+    required void Function(List<String> paths, Offset at) onDrop,
+    required Widget child,
+  }) =>
+      DropTarget(
+        key: key,
+        enable: enable,
+        onDragEntered: onEnter == null ? null : (_) => onEnter(),
+        onDragExited: onExit == null ? null : (_) => onExit(),
+        onDragDone: (d) => onDrop(DesktopDropX.pathsOf(d.files), d.localPosition),
+        child: child,
+      );
+}
+
+/// Close button / Alt+F4 run the orderly close instead.
+class _CloseGuard with WindowListener {
+  final Future<void> Function() onClose;
+  _CloseGuard(this.onClose);
+  @override
+  void onWindowClose() => unawaited(onClose());
+}
+
+class _MaximizeWatch with WindowListener {
+  final void Function(bool) onChange;
+  _MaximizeWatch(this.onChange);
+  @override
+  void onWindowMaximize() => onChange(true);
+  @override
+  void onWindowUnmaximize() => onChange(false);
+}
+
+/// Focus, blur, minimise and restore as [WindowActivity] (a restored
+/// window is shown; its focus event follows when it gets the keyboard).
+class _ActivityWatch with WindowListener {
+  final void Function(WindowActivity) onChange;
+  _ActivityWatch(this.onChange);
+  @override
+  void onWindowFocus() => onChange(WindowActivity.focused);
+  @override
+  void onWindowBlur() => onChange(WindowActivity.unfocused);
+  @override
+  void onWindowMinimize() => onChange(WindowActivity.minimised);
+  @override
+  void onWindowRestore() => onChange(WindowActivity.unfocused);
+}

apps/desktop/lib/src/platform/desktop/desktop_urls.dart

@@ -0,0 +1,26 @@
+import 'dart:io';
+
+import '../ports/url_opener.dart';
+
+/// [UrlOpener] without url_launcher: `xdg-open`, `open` or Windows'
+/// `url.dll` handler.
+class DesktopUrls implements UrlOpener {
+  const DesktopUrls();
+
+  @override
+  Future<bool> open(String url) async {
+    try {
+      final ProcessResult r;
+      if (Platform.isWindows) {
+        r = await Process.run('rundll32', ['url.dll,FileProtocolHandler', url]);
+      } else if (Platform.isMacOS) {
+        r = await Process.run('open', [url]);
+      } else {
+        r = await Process.run('xdg-open', [url]);
+      }
+      return r.exitCode == 0;
+    } catch (_) {
+      return false;
+    }
+  }
+}

apps/desktop/lib/src/platform/desktop/window_memory.dart

@@ -0,0 +1,106 @@
+import 'dart:async';
+import 'dart:io';
+import 'dart:ui';
+
+import 'package:flutter/foundation.dart';
+import 'package:hive_ce_flutter/hive_flutter.dart';
+import 'package:screen_retriever/screen_retriever.dart';
+import 'package:window_manager/window_manager.dart';
+
+/// The window's size, position and maximized state across restarts (and
+/// hot restarts), in the settings box. The size and position kept are
+/// the normal (unmaximized) ones; fullscreen is never saved or restored.
+/// Wayland lets no app place its own window, so there only the size and
+/// maximized state come back (the compositor decides the position).
+class WindowMemory with WindowListener {
+  static const _key = 'windowBounds';
+  static const defaultSize = Size(1280, 720);
+
+  // Null when the settings box failed to open: defaults, nothing saved.
+  final Box? _box;
+  Timer? _save;
+  WindowMemory(this._box);
+
+  static bool get _canPlace => !(Platform.isLinux && Platform.environment['WAYLAND_DISPLAY'] != null);
+
+  Map? get _saved => _box?.get(_key) is Map ? _box!.get(_key) as Map : null;
+
+  /// The size to open at: the last normal size, else [defaultSize].
+  Size get size {
+    final s = _saved;
+    final w = s?['w'], h = s?['h'];
+    return w is num && h is num && w >= 160 && h >= 90 ? Size(w.toDouble(), h.toDouble()) : defaultSize;
+  }
+
+  /// Whether a saved position exists to place the window at (else center).
+  bool get hasPosition => _canPlace && _saved?['x'] is num && _saved?['y'] is num;
+
+  /// After the window shows: back to the saved position when it still
+  /// lands on a connected display, maximized when it was; then listens.
+  Future<void> restore() async {
+    final s = _saved;
+    try {
+      if (s != null && hasPosition) {
+        final rect = Offset((s['x'] as num).toDouble(), (s['y'] as num).toDouble()) & size;
+        if (await _onSomeDisplay(rect)) {
+          await windowManager.setPosition(rect.topLeft);
+        } else {
+          await windowManager.center();
+        }
+      }
+      if (s?['max'] == true) await windowManager.maximize();
+    } catch (e) {
+      debugPrint('window restore failed: $e');
+    }
+    windowManager.addListener(this);
+  }
+
+  // At least a 100×50 corner of the title area on a display's visible area.
+  static Future<bool> _onSomeDisplay(Rect r) async {
+    final grip = Rect.fromLTWH(r.left, r.top, r.width.clamp(0, 100).toDouble(), 50);
+    for (final d in await screenRetriever.getAllDisplays()) {
+      final area = (d.visiblePosition ?? Offset.zero) & (d.visibleSize ?? d.size);
+      if (area.overlaps(grip)) return true;
+    }
+    return false;
+  }
+
+  void _later() {
+    _save?.cancel();
+    _save = Timer(const Duration(milliseconds: 400), () => unawaited(save()));
+  }
+
+  /// Writes the current state now (also on close).
+  Future<void> save() async {
+    _save?.cancel();
+    final box = _box;
+    if (box == null) return;
+    try {
+      if (await windowManager.isFullScreen() || await windowManager.isMinimized()) return;
+      final max = await windowManager.isMaximized();
+      final s = Map<String, Object?>.of((_saved ?? const {}).cast<String, Object?>());
+      s['max'] = max;
+      if (!max) {
+        final b = await windowManager.getBounds();
+        s['w'] = b.width;
+        s['h'] = b.height;
+        if (_canPlace) {
+          s['x'] = b.left;
+          s['y'] = b.top;
+        }
+      }
+      await box.put(_key, s);
+    } catch (e) {
+      debugPrint('window save failed: $e');
+    }
+  }
+
+  @override
+  void onWindowResized() => _later();
+  @override
+  void onWindowMoved() => _later();
+  @override
+  void onWindowMaximize() => _later();
+  @override
+  void onWindowUnmaximize() => _later();
+}

apps/desktop/lib/src/platform/desktop_entry.dart

@@ -0,0 +1,77 @@
+import 'dart:io';
+
+import 'package:flutter/foundation.dart';
+import 'package:sync_relay_core/core.dart' show findInstallRoot;
+
+/// The app's id: GTK's application id, so the Wayland `app_id` the
+/// compositor matches to [desktopFileName] for the window's icon.
+const appId = 'dev.foxyz.starsync';
+const desktopFileName = '$appId.desktop';
+
+/// The app id up to 1.2.x: its entry and icons are removed (only those
+/// exact files, which that version wrote).
+const legacyAppId = 'moe.senkochan.watch_together';
+
+const _iconSizes = [16, 32, 48, 64, 128, 256, 512];
+
+/// Linux release installs (an unpacked tarball) carry no launcher entry, so
+/// Wayland shows a generic icon. On start: write the `.desktop` file into
+/// `~/.local/share/applications` (Exec = this binary) and the icon into
+/// the hicolor theme, only when something changed (a moved install, a new
+/// icon). The entry and icons of [legacyAppId] go. Never in debug runs
+/// (unless [force], for tests); failures only log.
+Future<void> installDesktopEntry(
+    {String? executable, String? dataHome, String? home, @visibleForTesting bool force = false}) async {
+  if (!Platform.isLinux || (kDebugMode && !force)) return;
+  try {
+    final exe = executable ?? Platform.resolvedExecutable;
+    final root = findInstallRoot(exe, windows: false);
+    if (root == null) return;
+    final share = dataHome ?? Platform.environment['XDG_DATA_HOME'] ??
+        '${home ?? Platform.environment['HOME']}/.local/share';
+    final icons = '${root.path}/data/flutter_assets/assets/icon';
+    await _removeLegacy(share);
+    for (final size in _iconSizes) {
+      final src = File('$icons/icon_$size.png');
+      if (!src.existsSync()) continue;
+      final dst = File('$share/icons/hicolor/${size}x$size/apps/$appId.png');
+      if (dst.existsSync() && dst.lengthSync() == src.lengthSync()) continue;
+      await dst.parent.create(recursive: true);
+      await src.copy(dst.path);
+    }
+    final entry = desktopEntryText(exe);
+    final file = File('$share/applications/$desktopFileName');
+    if (file.existsSync() && file.readAsStringSync() == entry) return;
+    await file.parent.create(recursive: true);
+    await file.writeAsString(entry);
+  } catch (e) {
+    debugPrint('desktop entry: $e');
+  }
+}
+
+Future<void> _removeLegacy(String share) async {
+  for (final f in [
+    File('$share/applications/$legacyAppId.desktop'),
+    for (final size in _iconSizes) File('$share/icons/hicolor/${size}x$size/apps/$legacyAppId.png'),
+  ]) {
+    if (!f.existsSync()) continue;
+    try {
+      await f.delete();
+      debugPrint('desktop entry: removed ${f.path}');
+    } catch (e) {
+      debugPrint('desktop entry: cannot remove ${f.path}: $e');
+    }
+  }
+}
+
+@visibleForTesting
+String desktopEntryText(String exe) => '''[Desktop Entry]
+Type=Application
+Name=Starsync
+Comment=Watch videos in sync with friends
+Exec="$exe"
+Icon=$appId
+StartupWMClass=$appId
+Categories=AudioVideo;Video;Player;Network;
+Terminal=false
+''';

apps/desktop/lib/src/platform/ports/app_dirs.dart

@@ -0,0 +1,69 @@
+import 'dart:io';
+
+/// The environment variable that picks a separate profile (DEVELOPMENT.md
+/// "Dev loop": two instances on one machine).
+const profileEnv = 'STARSYNC_PROFILE';
+
+/// Where the app keeps its own files, resolved once in `main` through an
+/// [AppDirsPort] and handed on from there.
+///
+/// Everything lives in the app support folder: Hive's boxes in
+/// `<app support>/hive`, the logs in `<app support>/logs`. With
+/// `STARSYNC_PROFILE=<name>` (letters, digits, `-`, `_`; at most 32) the
+/// per-install data moves to `<app support>/profiles/<name>/`: the Hive
+/// boxes (settings and so the profile, connect form, window bounds,
+/// folders, Jellyfin sign-ins; the client id from restructure step 1 on)
+/// under `hive/`, the logs under `logs/`. Downloads and caches stay
+/// shared: yt-dlp and its cookies, the extracted shaders, thumbnails, the
+/// AniList cache.
+class AppDirs {
+  /// The profile name; null for the normal app.
+  final String? profile;
+  /// The app support folder (yt-dlp, shaders; Hive and logs without a
+  /// profile).
+  final String support;
+  /// Hive's folder.
+  final String hive;
+  /// The app's log folder.
+  final String logs;
+  /// What resolving copied over from before the rename, one line each
+  /// (paths and counts), for the log once it is open.
+  final List<String> migrated;
+
+  const AppDirs(
+      {required this.profile,
+      required this.support,
+      required this.hive,
+      required this.logs,
+      this.migrated = const []});
+
+  /// The layout for [support] (the app support folder) and [env]; an
+  /// invalid profile name is ignored ([invalidProfile] says which).
+  static AppDirs fromEnv(
+      {required String support, required Map<String, String> env, List<String> migrated = const []}) {
+    final sep = Platform.pathSeparator;
+    final name = validProfile(env[profileEnv]);
+    final root = name == null ? support : '$support${sep}profiles$sep$name';
+    return AppDirs(
+        profile: name, support: support, hive: '$root${sep}hive', logs: '$root${sep}logs', migrated: migrated);
+  }
+
+  /// [raw] when it is a usable profile name, else null.
+  static String? validProfile(String? raw) {
+    final v = raw?.trim() ?? '';
+    return RegExp(r'^[A-Za-z0-9_-]{1,32}$').hasMatch(v) ? v : null;
+  }
+
+  /// The env value when it is set but not a usable name (for a warning).
+  static String? invalidProfile(Map<String, String> env) {
+    final raw = env[profileEnv];
+    return raw != null && raw.trim().isNotEmpty && validProfile(raw) == null ? raw : null;
+  }
+}
+
+/// Finds the app's folders on this platform (and, the first time, brings
+/// over the data of the names before the rename).
+abstract interface class AppDirsPort {
+  /// The layout for this process; its Hive folder exists afterwards.
+  Future<AppDirs> resolve();
+}

apps/desktop/lib/src/platform/ports/folder_access.dart

@@ -0,0 +1,28 @@
+import 'dart:io' show FileStat;
+
+import '../../files/scanner.dart' show FolderScan;
+
+/// The user's folders and files: picking them, listing videos, looking a
+/// path up. Paths for now; a platform without them (Android's tree URIs)
+/// brings its own implementation.
+abstract interface class FolderAccess {
+  /// The system folder dialog; null when cancelled.
+  Future<String?> pickFolder({required String dialogTitle});
+
+  /// The system file dialog limited to [extensions]; the picked paths
+  /// (empty when cancelled).
+  Future<List<String>> pickFiles({required String dialogTitle, required List<String> extensions});
+
+  /// The videos under [dir] (see [FolderScan]); never throws.
+  Future<FolderScan> scan(String dir);
+
+  /// Whether the folder [dir] exists.
+  bool folderExists(String dir);
+
+  /// Size and dates of [path]; throws when it is gone.
+  Future<FileStat> stat(String path);
+
+  /// Shows the folder [dir] in the file manager; false when nothing
+  /// opened it.
+  Future<bool> reveal(String dir);
+}

apps/desktop/lib/src/platform/ports/link_resolver.dart

@@ -0,0 +1,21 @@
+import 'package:sync_relay_core/core.dart' show LinkProbe, YtDlp;
+
+/// Web page links: what they are and how they play, through the app's
+/// yt-dlp (a process on desktop).
+abstract interface class LinkResolver {
+  /// The yt-dlp behind it (relaying a link, cookies, the hosted server's
+  /// shared folder).
+  Future<YtDlp> get ytDlp;
+
+  /// Gets it ready in the background (download on first run, updates).
+  void warmUp();
+
+  /// mpv's `ytdl-raw-options` (sub languages, cookies).
+  Future<String> mpvRawOptions();
+
+  /// What [url] is, remembered for a while ([keep]); [fresh] asks again.
+  Future<LinkProbe> probe(String url, {Duration keep, bool fresh});
+
+  /// [url] no longer needs keeping longer than usual.
+  void release(String url);
+}

apps/desktop/lib/src/platform/ports/ports.dart

@@ -0,0 +1,29 @@
+import 'folder_access.dart';
+import 'link_resolver.dart';
+import 'shell_port.dart';
+import 'system_notifications.dart';
+import 'url_opener.dart';
+
+export 'app_dirs.dart';
+export 'folder_access.dart';
+export 'link_resolver.dart';
+export 'shell_port.dart';
+export 'system_notifications.dart';
+export 'url_opener.dart';
+
+/// The platform as the app sees it: one set, made in the composition
+/// root ([SessionState]) and handed on from there.
+class Ports {
+  final ShellPort shell;
+  final UrlOpener urls;
+  final FolderAccess folders;
+  final LinkResolver links;
+  final SystemNotifications notifications;
+  const Ports({
+    required this.shell,
+    required this.urls,
+    required this.folders,
+    required this.links,
+    required this.notifications,
+  });
+}

apps/desktop/lib/src/platform/ports/shell_port.dart

@@ -0,0 +1,66 @@
+import 'package:flutter/widgets.dart';
+
+import 'window_activity.dart';
+
+export 'window_activity.dart';
+
+/// What the clipboard holds for a paste: its files, else its text.
+typedef Paste = ({List<String> files, String? text});
+
+/// The app window and what the desktop hands it (drops, pastes). The
+/// desktop implementation wraps window_manager and fox_utils
+/// ([DesktopShell]); another platform brings its own.
+abstract interface class ShellPort {
+  /// Before the first frame: the window shown at its remembered size and
+  /// place; a close request (close button, Alt+F4) runs [onCloseRequest]
+  /// instead of closing.
+  Future<void> start({required String title, required Future<void> Function() onCloseRequest});
+
+  Future<void> setFullScreen(bool on);
+  Future<void> minimize();
+  Future<bool> isMaximized();
+  Future<void> maximize();
+  Future<void> unmaximize();
+
+  /// Calls [onChange] whenever the window is maximized or restored;
+  /// returns the call that stops it.
+  void Function() watchMaximized(void Function(bool maximized) onChange);
+
+  /// Calls [onChange] whenever the window gains or loses the focus, is
+  /// minimised, restored or hidden; returns the call that stops it.
+  void Function() watchActivity(void Function(WindowActivity activity) onChange);
+
+  /// Moves the window with the pointer (a press on the title area).
+  Future<void> startDragging();
+
+  /// Asks to close the window: the same path as the close button.
+  Future<void> requestClose();
+
+  /// The way out: remembers the window, hides it ([hide]), and later
+  /// closes it for good ([quit]).
+  Future<void> saveWindow();
+  Future<void> hide();
+  Future<void> quit();
+
+  /// Brings the window up and gives it the focus (restored when
+  /// minimised, shown when hidden): a click on a system notification.
+  Future<void> focus();
+
+  /// Points the desktop at the window when it is not focused (taskbar
+  /// flash, urgency hint); nothing when it is.
+  Future<void> requestAttention();
+
+  /// The clipboard's files, else its text (Ctrl+V outside a text field).
+  Future<Paste> readPaste();
+
+  /// [child] taking dropped files ([onDrop]: their paths and where they
+  /// landed); [enable] off lets drops through.
+  Widget dropTarget({
+    Key? key,
+    bool enable = true,
+    VoidCallback? onEnter,
+    VoidCallback? onExit,
+    required void Function(List<String> paths, Offset at) onDrop,
+    required Widget child,
+  });
+}

apps/desktop/lib/src/platform/ports/system_notifications.dart

@@ -0,0 +1,23 @@
+/// Notifications outside the window (the desktop's notification center,
+/// Android's shade). The Notifier decides what goes out here (see
+/// `noticeFor`); the port only shows them and reports clicks.
+abstract interface class SystemNotifications {
+  /// Shows [title] / [body] with the app's name and icon; one with the
+  /// same [tag] replaces it. [payload] comes back to [onClick].
+  Future<void> show({required String title, required String body, String tag = '', String payload = ''});
+
+  /// Called with a notification's payload when the user clicks it (set
+  /// once, by the Notifier).
+  set onClick(void Function(String payload)? handler);
+}
+
+/// Shows nothing (tests, platforms without one).
+class NoSystemNotifications implements SystemNotifications {
+  const NoSystemNotifications();
+
+  @override
+  Future<void> show({required String title, required String body, String tag = '', String payload = ''}) async {}
+
+  @override
+  set onClick(void Function(String payload)? handler) {}
+}

apps/desktop/lib/src/platform/ports/url_opener.dart

@@ -0,0 +1,6 @@
+/// Opens links outside the app.
+abstract interface class UrlOpener {
+  /// Opens [url] with the system's handler (a browser for web links, the
+  /// file manager for a `file:` folder); false when nothing opened it.
+  Future<bool> open(String url);
+}

apps/desktop/lib/src/platform/ports/window_activity.dart

@@ -0,0 +1,19 @@
+/// Where the app window stands ([ShellPort.watchActivity]): auto sit-out
+/// and the Notifier (system notifications while it is not focused) read
+/// it. Pure Dart.
+enum WindowActivity {
+  /// The window has the keyboard focus.
+  focused,
+
+  /// Shown, but another window has the focus.
+  unfocused,
+
+  /// Minimised to the taskbar.
+  minimised,
+
+  /// Hidden (closing, or a platform that hides instead of minimising).
+  hidden;
+
+  /// Not in front of the user: notices go out as system notifications.
+  bool get background => this != focused;
+}

apps/desktop/lib/src/playback/frame_watchdog.dart

@@ -1,120 +0,0 @@
-import 'dart:typed_data';
-
-/// FNV-1a over a 15x15 grid of RGB(A) pixels in the central half of an
-/// image. Used on a small capture of what the compositor shows: the
-/// centre is video, the edges carry the (changing) control overlays.
-int hashCenterPixels(ByteData rgba, int width, int height) {
-  var x = 0x811c9dc5;
-  if (width <= 0 || height <= 0) return x;
-  for (var gy = 1; gy < 16; gy++) {
-    for (var gx = 1; gx < 16; gx++) {
-      final px = (width * (0.25 + 0.5 * gx / 16)).floor();
-      final py = (height * (0.25 + 0.5 * gy / 16)).floor();
-      final o = (py * width + px) * 4;
-      if (o + 3 > rgba.lengthInBytes) continue;
-      for (var c = 0; c < 3; c++) {
-        x = ((x ^ rgba.getUint8(o + c)) * 0x01000193) & 0xffffffff;
-      }
-    }
-  }
-  return x;
-}
-
-/// FNV-1a over ~4k bytes spread evenly across a raw frame (mpv
-/// `screenshot-raw`); dimension-agnostic, enough to tell frames apart.
-int hashSpread(Uint8List bytes) {
-  var x = 0x811c9dc5;
-  if (bytes.isEmpty) return x;
-  final step = bytes.length <= 4096 ? 1 : bytes.length ~/ 4096;
-  for (var i = 0; i < bytes.length; i += step) {
-    x = ((x ^ bytes[i]) * 0x01000193) & 0xffffffff;
-  }
-  return x;
-}
-
-/// One sample of player state, taken about once a second.
-class FrameSample {
-  final DateTime at;
-  final double position;
-
-  /// Fingerprint of the picture currently shown on screen; null when it
-  /// cannot be captured (no view, hidden window, headless).
-  final int? frames;
-
-  /// Playing, not buffering, rate > 0, video track present, window
-  /// visible. Anything else disarms the watchdog.
-  final bool eligible;
-  const FrameSample({
-    required this.at,
-    required this.position,
-    required this.frames,
-    required this.eligible,
-  });
-}
-
-/// Detects a frozen picture: position advances normally but the shown
-/// picture stands still for [stallAfter]. Seeks (position jumps), pauses,
-/// buffering and missing captures all reset the stall clock. A hit is a
-/// suspicion only — a still scene looks the same — so the caller confirms
-/// it against the decoder and calls [dismiss] when it was a still scene.
-/// Fires at most once until the picture is seen moving again for
-/// [rearmAfter], so a player that stays (or soon gets) frozen after a
-/// reload does not reload in a loop. [reset] keeps that latch.
-class FrameWatchdog {
-  static const stallAfter = Duration(seconds: 3);
-  static const rearmAfter = Duration(seconds: 10);
-
-  FrameSample? _last;
-  DateTime? _stallSince;
-  DateTime? _healthySince;
-  bool _fired = false;
-
-  void reset() {
-    _last = null;
-    _stallSince = null;
-    _healthySince = null;
-  }
-
-  /// The last hit was a still scene: re-arm, but wait a full
-  /// [stallAfter] before suspecting again.
-  void dismiss() {
-    _fired = false;
-    _stallSince = null;
-  }
-
-  /// Returns true exactly when a freeze is suspected.
-  bool feed(FrameSample s) {
-    final last = _last;
-    _last = s;
-    if (!s.eligible || s.frames == null || last == null ||
-        !last.eligible || last.frames == null) {
-      _stallSince = null;
-      _healthySince = null;
-      return false;
-    }
-    if (s.frames != last.frames) {
-      _stallSince = null;
-      _healthySince ??= last.at;
-      if (s.at.difference(_healthySince!) >= rearmAfter) _fired = false;
-      return false;
-    }
-    _healthySince = null;
-    final wall = s.at.difference(last.at).inMilliseconds / 1000.0;
-    final moved = s.position - last.position;
-    // Normal playback only: a jump (seek) or a standstill (stall, the
-    // position itself stuck) is not a frozen picture.
-    final normal = wall > 0 && moved > wall * 0.5 && moved < wall * 2 + 0.5;
-    if (!normal) {
-      _stallSince = null;
-      return false;
-    }
-    _stallSince ??= last.at;
-    if (_fired) return false;
-    if (s.at.difference(_stallSince!) >= stallAfter) {
-      _fired = true;
-      _stallSince = null;
-      return true;
-    }
-    return false;
-  }
-}

apps/desktop/lib/src/playback/playback_controller.dart

@@ -1,12 +1,14 @@
 import 'dart:async';
+import 'dart:ffi' show Int8;
 import 'dart:io';
 
-import 'package:flutter/foundation.dart' show listEquals;
+import 'package:ffi/ffi.dart' show StringUtf8Pointer, malloc;
+import 'package:flutter/foundation.dart' show listEquals, mapEquals;
 import 'package:flutter/widgets.dart';
 import 'package:media_kit/media_kit.dart';
 import 'package:media_kit_video/media_kit_video.dart';
 import 'package:signals/signals_flutter.dart';
-import 'package:sync_relay_core/core.dart' show JellyfinStreamType;
+import 'package:sync_relay_core/core.dart' show JellyfinStreamType, LogThrottle, createLogger;
 
 import '../jellyfin/track_prefs.dart' show MpvTrack;
 import '../shaders/shader_assets.dart';
@@ -14,20 +16,23 @@ import '../shaders/shader_presets.dart';
 import '../state/settings.dart';
 import '../sync/state_diff.dart';
 import '../sync/user_seek.dart';
-import 'frame_watchdog.dart';
 import 'media_marks.dart';
+import 'yt_dlp_app.dart' show AppYtDlp, ytdlFormat;
 
-/// Owns one mpv [Player] (and its [VideoController]) per session: created
+/// Owns the session's mpv [Player] (and its [VideoController]): created
 /// by [init] on join, released by [dispose] on leave, swapped by
-/// [recreate] for "Reload video". Never reuse a player across sessions —
-/// a GPU-side freeze sticks to the player, not to the widget.
+/// [recreate] for "Reload video" and by [openUrl] for every new media (a
+/// promoted preload or a fresh player). Never reuse a player for other
+/// media — a GPU-side freeze sticks to the player, not to the widget.
 class PlaybackController {
   /// Read-ahead target: about two minutes rides out short outages and
   /// makes skipping an intro instant.
   static const readAheadSecs = 150;
   /// Forward demuxer cache. Holds [readAheadSecs] up to ~14 Mbit/s (a
   /// 1.4 GB / 24 min file is ~8); higher bitrates get less time. In RAM:
-  /// media_kit sets cache-on-disk but no cache-dir, so mpv falls back.
+  /// `cache-on-disk=no` (media_kit sets it on but no cache-dir, so mpv
+  /// fell back to RAM anyway, warning "Failed to create file cache." per
+  /// open).
   static const maxBytes = 256 * 1024 * 1024;
   /// Back buffer (media_kit sets it to bufferSize too): enough for a short
   /// seek back without holding another 256 MiB.
@@ -38,9 +43,6 @@ class PlaybackController {
 
   SyncPlayer? _player;
   VideoController? _video;
-  Timer? _watchTimer;
-  bool _probing = false;
-  final FrameWatchdog _watchdog = FrameWatchdog();
   StreamSubscription<PlayerLog>? _logSub;
   final List<StreamSubscription<Object?>> _timeSubs = [];
   String _chapterJson = '';
@@ -57,12 +59,53 @@ class PlaybackController {
   /// otherwise, so no texture outlives its player.
   final alive = signal(false);
 
-  /// Called once when the watchdog sees a frozen picture.
-  void Function()? onFrozen;
+  /// mpv's yt-dlp hook could not open the current link (its error text).
+  void Function(String error)? onYtdlError;
 
-  /// Fingerprint of the picture on screen, installed by the video view
-  /// (`ShownFrameProbe.sample`). Without it the watchdog stays idle.
-  Future<int?> Function()? shownFrame;
+  /// The current media failed to load (the HTTP error when there was one,
+  /// e.g. a CDN's 403), at most once per [openUrl].
+  void Function(String error)? onLoadError;
+
+  // Per opened media: the last HTTP error ffmpeg logged, and whether a
+  // load error was reported.
+  String? _httpError;
+  bool _loadErrorSent = false;
+
+  /// mpv's log level for this app. media_kit drains mpv's log on the UI
+  /// thread one line at a time, so a chatty level (ffmpeg retrying a
+  /// refused request logs every attempt) can starve the UI: warnings and
+  /// errors only, except while the video output starts ([video]), when
+  /// the render-mode probe needs mpv's verbose GL init lines.
+  static const logLevel = 'warn';
+
+  /// Points mpv's yt-dlp hook at [path] (the app's managed copy) for web
+  /// page links, at most 1080p, once per player; its cookies
+  /// (`ytdl-raw-options`) whenever they changed.
+  Future<void> useYtDlp(String path) async {
+    final p = _player;
+    if (p == null) return;
+    try {
+      _ytdlPath = path;
+      final dynamic platform = p.platform;
+      if (!identical(p, _ytdlSetOn)) {
+        await platform?.setProperty('script-opts', 'ytdl_hook-ytdl_path=$path');
+        await platform?.setProperty('ytdl-format', ytdlFormat);
+        _ytdlSetOn = p;
+        _ytdlRaw = '';
+      }
+      final raw = await AppYtDlp.instance.mpvRawOptions();
+      if (raw != _ytdlRaw && identical(p, _player)) {
+        await platform?.setProperty('ytdl-raw-options', raw);
+        _ytdlRaw = raw;
+      }
+    } catch (e) {
+      debugPrint('yt-dlp path not set: $e');
+    }
+  }
+
+  Player? _ytdlSetOn;
+  String _ytdlRaw = '';
+  String? _ytdlPath;
 
   Player get player => _player!;
 
@@ -108,6 +151,9 @@ class PlaybackController {
   /// `demuxer-cache-time`, media_kit's `buffer`), in 250 ms steps.
   final buffered = signal(Duration.zero);
 
+  /// The player's volume, 0..[maxVolume] (media_kit's `volume`).
+  final volume = signal(100.0);
+
   /// The opening ([openingRange]: Intro segment, else an OP-titled
   /// chapter) and the ending ([endingRange]: Outro, else ED-titled).
   late final Computed<SkipRange?> opening =
@@ -131,6 +177,8 @@ class PlaybackController {
     final existing = _video;
     if (existing != null) return existing;
     final hwdec = _hwdecOverride;
+    _logRenderEnv();
+    _requestLog(player, 'v'); // back to [logLevel] by _detectRenderMode
     // media_kit's video output sets hwdec itself on attach ('auto' unless
     // configured), which used to override SYNC_RELAY_HWDEC.
     final video = _video = VideoController(
@@ -149,17 +197,19 @@ class PlaybackController {
     return AppSettings.instance.hwdec.peek();
   }
 
+  SyncPlayer _newPlayer({required int bufferSize, required MPVLogLevel logLevel}) => SyncPlayer(
+          configuration: PlayerConfiguration(
+        bufferSize: bufferSize,
+        libass: true,
+        vo: Platform.environment['SYNC_RELAY_VO'],
+        logLevel: logLevel,
+      ))
+        ..onUserSeek = (d) => onUserSeek?.call(d);
+
   Future<void> init() async {
     if (_player != null) return;
-    _player = SyncPlayer(
-        configuration: PlayerConfiguration(
-      bufferSize: maxBytes,
-      libass: true,
-      vo: Platform.environment['SYNC_RELAY_VO'],
-      // Verbose: the render-mode probe needs mpv's GL init lines.
-      logLevel: MPVLogLevel.v,
-    ))
-      ..onUserSeek = (d) => onUserSeek?.call(d);
+    _player = _newPlayer(bufferSize: maxBytes, logLevel: MPVLogLevel.warn); // see [logLevel]
+    _held = false;
     _shaders = '';
     renderMode.value = RenderMode.unknown;
     shaderNotice.value = null;
@@ -168,8 +218,6 @@ class PlaybackController {
     await _pinBufferProps();
     await _pin('volume-max', '$maxVolume');
     await applyShaders();
-    _watchdog.reset();
-    _watchTimer = Timer.periodic(const Duration(seconds: 1), (_) => _watch());
     generation.value++;
     alive.value = true;
   }
@@ -187,9 +235,9 @@ class PlaybackController {
     }
   }
 
-  Future<void> _pin(String property, String value) async {
+  Future<void> _pin(String property, String value, [Player? on]) async {
     try {
-      final dynamic platform = player.platform;
+      final dynamic platform = (on ?? player).platform;
       await platform?.setProperty(property, value);
       final got = '${await platform?.getProperty(property)}';
       if (!pinMatches(value, got)) {
@@ -202,18 +250,40 @@ class PlaybackController {
     }
   }
 
-  Future<void> _pinBufferProps() async {
-    pinMismatches.clear();
-    await _pin('demuxer-readahead-secs', '$readAheadSecs');
-    await _pin('cache-secs', '$readAheadSecs');
-    await _pin('demuxer-max-bytes', '$maxBytes');
-    await _pin('demuxer-max-back-bytes', '$maxBackBytes');
+  Future<void> _pinBufferProps([Player? on, int ahead = maxBytes, int back = maxBackBytes]) async {
+    if (on == null) pinMismatches.clear();
+    await _pin('demuxer-readahead-secs', '$readAheadSecs', on);
+    await _pin('cache-secs', '$readAheadSecs', on);
+    await _pin('demuxer-max-bytes', '$ahead', on);
+    await _pin('demuxer-max-back-bytes', '$back', on);
+    await _pin('cache-on-disk', 'no', on);
     final hwdec = _hwdecOverride;
     if (hwdec != null) {
-      await _pin('hwdec', hwdec);
+      await _pin('hwdec', hwdec, on);
+    }
+    await _pin('stream-lavf-o', streamLavfOptions, on);
+  }
+
+  /// ffmpeg's HTTP options (mpv `stream-lavf-o`, comma form): reconnect
+  /// after a dropped connection, also on a streamed (growing) relay
+  /// response, and a server error (5xx) while connecting; a refused request
+  /// (4xx) fails at once. At most 3 tries per read, 4 s apart at most.
+  static const streamLavfOptions = 'reconnect_streamed=1,reconnect_on_http_error=5xx,'
+      'reconnect_delay_max=4,reconnect_max_retries=3';
+
+  // mpv_request_log_messages on [p]'s handle (media_kit has no API for it).
+  static void _requestLog(Player p, String level) {
+    try {
+      final dynamic platform = p.platform;
+      final name = level.toNativeUtf8();
+      try {
+        platform.mpv.mpv_request_log_messages(platform.ctx, name.cast<Int8>());
+      } finally {
+        malloc.free(name);
+      }
+    } catch (e) {
+      debugPrint('mpv log level $level not set: $e');
     }
-    await _pin('stream-lavf-o',
-        'reconnect_streamed=1,reconnect_on_http_error=1,reconnect_delay_max=4');
   }
 
   /// Puts the saved shader choice (Settings, Ctrl+0..6, shader button) on
@@ -244,13 +314,12 @@ class PlaybackController {
     }
     if (!identical(p, _player)) return;
     if (problem != null) paths = const [];
-    final value = joinShaderPaths(paths);
-    if (value != _shaders || problem != null) {
-      final got = await setShaderValue(value);
+    if (joinShaderPaths(paths) != _shaders || problem != null) {
+      final took = await setShaderPaths(paths);
       if (!identical(p, _player)) return;
-      if (problem == null && got != value) {
+      if (problem == null && !took) {
         problem = 'mpv did not take them';
-        await setShaderValue('');
+        await setShaderPaths(const []);
       }
     }
     if (problem != null) {
@@ -260,20 +329,23 @@ class PlaybackController {
     }
   }
 
-  /// Sets mpv `glsl-shaders` on the current player and returns the
-  /// read-back (null on error).
+  /// Sets mpv `glsl-shaders` to [paths] on the current player; true when
+  /// mpv's read-back is that list ([shaderListMatches]: old mpv prints it
+  /// joined with ',').
   @visibleForTesting
-  Future<String?> setShaderValue(String value) async {
+  Future<bool> setShaderPaths(List<String> paths) async {
+    final value = joinShaderPaths(paths);
     try {
       final dynamic platform = player.platform;
       await platform?.setProperty('glsl-shaders', value);
       final got = '${await platform?.getProperty('glsl-shaders')}';
-      _shaders = got;
-      if (got != value) debugPrint('glsl-shaders=$value not applied: "$got"');
-      return got;
+      final took = shaderListMatches(paths, got);
+      _shaders = took ? value : got;
+      if (!took) debugPrint('glsl-shaders=$value not applied: "$got"');
+      return took;
     } catch (e, st) {
       debugPrint('glsl-shaders=$value failed: $e\n$st');
-      return null;
+      return false;
     }
   }
 
@@ -298,7 +370,35 @@ class PlaybackController {
   // an error there while shaders are on is a shader that failed to load
   // or compile (mpv then renders without it).
   void _onLog(PlayerLog log) {
+    _toAppLog(log);
+    if (log.prefix == 'ytdl_hook' && (log.level == 'error' || log.level == 'fatal')) {
+      final text = log.text.trim().replaceFirst(RegExp(r'^ERROR:\s*'), '');
+      if (text.isNotEmpty) {
+        _loadErrorSent = true;
+        onYtdlError?.call(text);
+      }
+      return;
+    }
+    // ffmpeg logs through one mpv instance per process (the first one
+    // alive), so the HTTP status is a bonus, not a given.
+    if (log.prefix == 'ffmpeg') {
+      final http = RegExp(r'HTTP error \d{3}.*').firstMatch(log.text);
+      if (http != null) _httpError = http[0]!.trim();
+      return;
+    }
+    // Nothing playable opened (a track of mpv's yt-dlp EDL refused, ...).
+    if (!_loadErrorSent && _loadFailed(log, duration.peek())) {
+      _loadErrorSent = true;
+      final http = _httpError;
+      _mpvLog.warning('cannot open the media: [${log.prefix}] ${log.text.trim()}'
+          '${http == null ? ' (no HTTP error logged; a request that timed out after 5 s looks like this)' : ' ($http)'}');
+      onLoadError?.call(http == null ? 'the video stream could not be opened' : 'the video server answered $http');
+      return;
+    }
     if (log.prefix != 'libmpv_render') return;
+    // Which GL the video output got (verbose, heard only during the
+    // render-mode probe): kept in the app log.
+    if (_glInfo.hasMatch(log.text)) _mpvLog.info('render: [libmpv_render] ${log.text.trim()}');
     if (log.text.contains('suspected software renderer')) {
       _setRenderMode(RenderMode.softwareGl);
     } else if (log.text.startsWith('GL_VERSION') &&
@@ -311,12 +411,84 @@ class PlaybackController {
       _shaders = '';
       _shaderOp = _shaderOp.then((_) async {
         if (!identical(p, _player)) return;
-        await setShaderValue('');
+        await setShaderPaths(const []);
         _turnShadersOff('Shaders failed in mpv (${log.text}) — turned off');
       });
     }
   }
 
+  // mpv's warnings and errors (the session player's; ffmpeg's through
+  // whichever player logs them) go to the app log, a few per kind at a
+  // time: a refused request makes ffmpeg retry and warn on every try.
+  static final _mpvLog = createLogger('mpv');
+  static final _mpvThrottle = LogThrottle(burst: 5);
+
+  // mpv's GL init lines (`GL_VENDOR='...'`, `Detected desktop OpenGL 4.6.`).
+  static final _glInfo =
+      RegExp(r'^\s*(GL_(VENDOR|RENDERER|VERSION|SHADING_LANGUAGE_VERSION)=|Detected (GLES|desktop OpenGL))');
+
+  // Once per app start: what decides how media_kit and mpv render (the
+  // display server, Flutter's and Mesa's overrides). Not secrets.
+  static bool _renderEnvLogged = false;
+  static void _logRenderEnv() {
+    if (_renderEnvLogged || !Platform.isLinux) return;
+    _renderEnvLogged = true;
+    const names = [
+      'XDG_SESSION_TYPE',
+      'WAYLAND_DISPLAY',
+      'DISPLAY',
+      'GDK_BACKEND',
+      'FLUTTER_LINUX_RENDERER',
+      'LIBGL_ALWAYS_SOFTWARE',
+      '__EGL_VENDOR_LIBRARY_FILENAMES',
+    ];
+    final env = Platform.environment;
+    _mpvLog.info('render env: ${[for (final n in names) '$n=${env[n] ?? '-'}'].join(' ')}');
+  }
+
+  // Once per player, after its first frame: the decoder mpv picked; the
+  // first time per app start also mpv's and ffmpeg's versions.
+  static bool _versionsLogged = false;
+  Player? _frameLoggedFor;
+  Future<void> _logFirstFrame(Player p, int? width) async {
+    if (width == null || width <= 0 || identical(p, _frameLoggedFor)) return;
+    _frameLoggedFor = p;
+    try {
+      final dynamic platform = p.platform;
+      final current = await platform?.getProperty('hwdec-current');
+      final wanted = await platform?.getProperty('hwdec');
+      _mpvLog.info('render: first frame ${p.state.width}x${p.state.height}, '
+          'hwdec-current=${'$current'.isEmpty ? 'no' : current} (hwdec=$wanted), mode ${renderMode.peek().name}');
+      if (!_versionsLogged) {
+        _versionsLogged = true;
+        _mpvLog.info('render: ${await platform?.getProperty('mpv-version')}, '
+            'ffmpeg ${await platform?.getProperty('ffmpeg-version')}');
+      }
+    } catch (e) {
+      debugPrint('first frame info: $e');
+    }
+  }
+
+  static void _toAppLog(PlayerLog log, {String player = ''}) {
+    final level = log.level;
+    if (level != 'warn' && level != 'error' && level != 'fatal') return;
+    final text = log.text.trim();
+    if (text.isEmpty) return;
+    final pass = _mpvThrottle.allow('$player${log.prefix} $level ${text.length > 40 ? text.substring(0, 40) : text}');
+    if (pass == null) return;
+    final line = '$pass$player[${log.prefix}] $text';
+    level == 'warn' ? _mpvLog.info(line) : _mpvLog.warning(line);
+  }
+
+  /// [log] says the media could not be opened: before a [duration] is
+  /// known, mpv's fatal "nothing to play" or a demuxer error, or a yt-dlp
+  /// hook error.
+  static bool _loadFailed(PlayerLog log, Duration duration) {
+    if (log.prefix == 'ytdl_hook') return log.level == 'error' || log.level == 'fatal';
+    return duration == Duration.zero &&
+        ((log.prefix == 'cplayer' && log.level == 'fatal') || (log.prefix == 'demux' && log.level == 'error'));
+  }
+
   void _setRenderMode(RenderMode mode) {
     renderMode.value = mode;
     lastRenderMode.value = mode;
@@ -328,107 +500,77 @@ class PlaybackController {
   Future<void> _detectRenderMode(Player p, VideoController video) async {
     try {
       await video.platform.future;
+      await Future.delayed(const Duration(milliseconds: 1500));
     } catch (_) {
       return;
+    } finally {
+      if (identical(p, _player)) _requestLog(p, logLevel);
     }
-    await Future.delayed(const Duration(milliseconds: 1500));
-    if (!identical(p, _player) || renderMode.peek() != RenderMode.unknown) {
+    if (!identical(p, _player)) return;
+    final mode = renderMode.peek();
+    if (mode != RenderMode.unknown) {
+      _mpvLog.info('render: ${mode.name} (${mode == RenderMode.gpu ? 'OpenGL on the GPU' : 'OpenGL on the CPU'})');
       return;
     }
     _setRenderMode(RenderMode.software);
-    debugPrint('video output: software rendering (no GL init logged)');
+    _mpvLog.info("render: software (no GL init logged: media_kit's own fallback; "
+        'its reason is on stderr, "media_kit: VideoOutput: ..." when run from a terminal)');
     if (_shaders.isNotEmpty) {
       _notice('Shaders have no effect: video uses software rendering');
     }
   }
 
-  /// Fingerprint of the decoder's current frame (mpv `screenshot-raw`,
-  /// off-thread); null without video.
-  Future<int?> _sourceFrame(Player p) async {
+  /// `mpv-version` and `ffmpeg-version` of the session player, for
+  /// diagnostics; null when there is no player.
+  Future<String?> mpvVersion() async {
+    final p = _player;
+    if (p == null) return null;
     try {
-      final raw = await p.screenshot(format: null);
-      return raw == null || raw.isEmpty ? null : hashSpread(raw);
+      final dynamic platform = p.platform;
+      return '${await platform?.getProperty('mpv-version')}, ffmpeg ${await platform?.getProperty('ffmpeg-version')}';
     } catch (_) {
       return null;
     }
   }
 
-  /// A suspected freeze is real only if mpv's own frames still move: a
-  /// still scene looks frozen on screen too.
-  Future<bool> _sourceMoving(Player p) async {
-    final a = await _sourceFrame(p);
-    await Future.delayed(const Duration(milliseconds: 500));
-    if (!identical(p, _player) || !p.state.playing) return false;
-    final b = await _sourceFrame(p);
-    return a != null && b != null && a != b;
-  }
-
-  static bool get _windowVisible {
-    try {
-      final s = WidgetsBinding.instance.lifecycleState;
-      return s == null ||
-          s == AppLifecycleState.resumed ||
-          s == AppLifecycleState.inactive;
-    } catch (_) {
-      return false;
-    }
-  }
-
-  Future<void> _watch() async {
-    final p = _player;
-    final probe = shownFrame;
-    // Only meaningful once the video view is up.
-    if (p == null || _video == null || probe == null || _probing) return;
-    _probing = true;
-    try {
-      final frames = await probe();
-      if (!identical(p, _player)) return;
-      final s = p.state;
-      final eligible = s.playing &&
-          !s.buffering &&
-          !s.completed &&
-          s.rate > 0 &&
-          (s.width ?? 0) > 0 &&
-          _windowVisible;
-      final fired = _watchdog.feed(FrameSample(
-        at: DateTime.now(),
-        position: positionSecs,
-        frames: frames,
-        eligible: eligible,
-      ));
-      if (fired) {
-        if (await _sourceMoving(p) && identical(p, _player)) {
-          debugPrint('video watchdog: picture stuck while mpv frames move');
-          onFrozen?.call();
-        } else {
-          _watchdog.dismiss();
-        }
-      }
-    } finally {
-      _probing = false;
-    }
-  }
-
   /// Opens [url] paused. [headers] go with every request for it (mpv
   /// `http-header-fields`): a Jellyfin token travels there, not in the URL.
-  Future<void> openUrl(String url, {Map<String, String>? headers}) async {
-    if (!_ready) return;
+  /// Each media gets its own player: when [preload] holds the same [url]
+  /// and [headers], that player becomes this one (true: promoted, its
+  /// buffer comes along); else a player that already held media is
+  /// replaced by a fresh one first ([onFreshPlayer] once it is up), unless
+  /// [keepPlayer] (the same media again, e.g. after a reconnect).
+  Future<bool> openUrl(String url,
+      {Map<String, String>? headers, bool keepPlayer = false, void Function()? onFreshPlayer}) async {
+    if (!_ready) return false;
+    final pre = _pre;
+    if (pre != null && pre.matches(url, headers)) {
+      if (await _promote(pre)) return true;
+    }
+    if (_held && !keepPlayer && await _freshPlayer()) onFreshPlayer?.call();
+    if (!_ready) return false;
     try {
+      _held = true;
       _chapterJson = '';
+      _httpError = null;
+      _loadErrorSent = false;
       chapters.value = const [];
       tracks.value = const [];
       buffered.value = Duration.zero;
       // An empty map, not null: media_kit caches headers per URI.
       await player.open(Media(url, httpHeaders: headers ?? const {}), play: false);
+      return false;
     } catch (e, st) {
       debugPrint('open ${Uri.tryParse(url)?.replace(query: '') ?? 'media'} failed: $e\n$st');
       rethrow;
     }
   }
 
-  // Position / duration from media_kit's streams; chapter-list and
+  // Position, duration and volume from media_kit's streams; chapter-list and
   // track-list observed in mpv (read back as JSON).
   void _watchMarks(SyncPlayer p) {
+    volume.value = p.state.volume;
+    _timeSubs.add(p.stream.volume.listen((v) => volume.value = v));
     _timeSubs.add(p.stream.position.listen((d) {
       // At the end the bar shows full: mpv's last position is the last
       // frame's start (and the 250 ms steps round down), short of duration.
@@ -442,6 +584,8 @@ class PlaybackController {
     _timeSubs.add(p.stream.completed.listen((done) {
       if (done && duration.value > Duration.zero) position.value = duration.value;
     }));
+    _timeSubs.add(p.stream.width.listen((w) => _logFirstFrame(p, w)));
+    unawaited(_logFirstFrame(p, p.state.width)); // a promoted preload has one already
     _timeSubs.add(p.stream.buffer.listen((d) {
       final ms = d.inMilliseconds;
       buffered.value = Duration(milliseconds: ms - ms % 250);
@@ -588,10 +732,9 @@ class PlaybackController {
   /// Release the player. The view drops its texture first ([alive] goes
   /// false, one frame passes), then mpv is torn down.
   Future<void> dispose() async {
+    await dropPreload();
     final p = _player;
     if (p == null) return;
-    _watchTimer?.cancel();
-    _watchTimer = null;
     await _logSub?.cancel();
     _logSub = null;
     for (final sub in _timeSubs) {
@@ -600,6 +743,7 @@ class PlaybackController {
     _timeSubs.clear();
     _player = null;
     _video = null;
+    _held = false;
     alive.value = false;
     _clearMarks();
     await _settleUi();
@@ -608,6 +752,24 @@ class PlaybackController {
     } catch (_) {}
   }
 
+  /// App close: every mpv this controller holds goes before the engine
+  /// does (a live one calls back into a dead isolate): the preload, the
+  /// session player and the one still retiring, each bounded by [each].
+  /// A player an open in flight brought up meanwhile goes too.
+  Future<void> disposeAll({Duration each = const Duration(milliseconds: 1500)}) async {
+    Future<void> bounded(Future<void> f) => f.timeout(each).catchError((Object _) {});
+    for (var round = 0; round < 2; round++) {
+      final pre = _pre;
+      _pre = null;
+      await Future.wait([
+        if (pre != null) bounded(_disposePreload(pre)),
+        bounded(_retiring),
+        bounded(dispose()),
+      ]);
+      if (_player == null && _pre == null) return;
+    }
+  }
+
   // Two frames: one may already be mid-build when [alive] flips. Then
   // the length of a route pop (the fullscreen route holds its own `Video`
   // and leaves animated). Bounded, since a hidden window renders no
@@ -622,6 +784,246 @@ class PlaybackController {
     } catch (_) {}
   }
 
+  // ------------------------------------------------------------ preload
+  //
+  // A second, hidden player holding what plays next (Up next's first
+  // item), open paused at its start and muted, with a small cache: its
+  // first seconds are in before anyone asks. [openUrl] for the same URL
+  // promotes it to the session player (see ARCHITECTURE.md "Getting
+  // ready"). One at a time.
+
+  /// Preloading on (env `SYNC_RELAY_PRELOAD=0` turns it off; tests set it).
+  bool preloadEnabled = Platform.environment['SYNC_RELAY_PRELOAD'] != '0';
+
+  /// The preload's forward cache: its first seconds and the container's
+  /// index, at little memory. Raised to [maxBytes] when promoted.
+  static const preloadBytes = 48 * 1024 * 1024;
+  static const _preloadBackBytes = 8 * 1024 * 1024;
+
+  _Preload? _pre;
+
+  /// The URL preloaded now (null: none).
+  String? get preloadUrl => _pre?.url;
+
+  /// Opens [url] in the hidden preload player (replacing any other), and
+  /// completes once [need] seconds are buffered or the whole media is:
+  /// true, false when it failed (or was dropped or replaced meanwhile).
+  /// The same [url] and [headers] again is the same preload unless
+  /// [fresh]. [ytdlPath]: mpv's yt-dlp hook for web pages.
+  Future<bool> preload(String url,
+      {Map<String, String>? headers, String? ytdlPath, double need = 4, bool fresh = false}) async {
+    if (!preloadEnabled || !_ready) return false;
+    final had = _pre;
+    if (had != null && had.matches(url, headers) && !had.failed && !fresh) return had.ready.future;
+    // Set before any await: a second call for the same URL finds it.
+    _pre = null;
+    if (had != null) unawaited(_disposePreload(had));
+    final p = _newPlayer(bufferSize: preloadBytes, logLevel: MPVLogLevel.error);
+    final pre = _pre = _Preload(p, url, headers ?? const {});
+    pre.logSub = p.stream.log.listen((log) {
+      // ffmpeg logs through one mpv per process: the first one, and once
+      // that is gone (a promotion disposes it) the next one created, which
+      // can be this preload. Its HTTP errors still name the session's.
+      if (log.prefix == 'ffmpeg') return _onLog(log);
+      _toAppLog(log, player: 'preload ');
+      if (_loadFailed(log, p.state.duration)) pre.fail();
+    });
+    try {
+      await _pinBufferProps(p, preloadBytes, _preloadBackBytes);
+      await _pin('volume-max', '$maxVolume', p);
+      await _pin('mute', 'yes', p);
+      final path = ytdlPath ?? _ytdlPath;
+      if (path != null) {
+        pre.ytdlRaw = await _setYtdl(p, path);
+        pre.ytdl = true;
+      }
+      // With a view up, its own video output: mpv decodes (media_kit
+      // starts players with vid=no) and the first frame is there.
+      if (_video != null) {
+        pre.video = VideoController(p, configuration: VideoControllerConfiguration(hwdec: _hwdecOverride));
+        await pre.video!.platform.future;
+      }
+      if (!identical(_pre, pre)) {
+        pre.fail();
+        return false;
+      }
+      await p.open(Media(url, httpHeaders: headers ?? const {}), play: false);
+      if (!pre.opened.isCompleted) pre.opened.complete();
+    } catch (e) {
+      debugPrint('preload failed: $e');
+      pre.fail();
+      return false;
+    }
+    unawaited(_watchPreload(pre, need));
+    return pre.ready.future;
+  }
+
+  Future<void> _watchPreload(_Preload pre, double need) async {
+    final end = DateTime.now().add(const Duration(seconds: 60));
+    while (identical(_pre, pre) && !pre.failed && DateTime.now().isBefore(end)) {
+      final st = pre.player.state;
+      final secs = st.duration.inMilliseconds / 1000;
+      final buffered = (st.buffer - st.position).inMilliseconds / 1000;
+      if (secs > 0 && (buffered >= need || st.buffer.inMilliseconds / 1000 >= secs - 0.5)) {
+        if (!pre.ready.isCompleted) pre.ready.complete(true);
+        return;
+      }
+      await Future.delayed(const Duration(milliseconds: 200));
+    }
+    if (!pre.ready.isCompleted) pre.ready.complete(false);
+  }
+
+  /// Drops the preload (nothing to get ready, or something else is).
+  Future<void> dropPreload() async {
+    final pre = _pre;
+    if (pre == null) return;
+    _pre = null;
+    await _disposePreload(pre);
+  }
+
+  Future<void> _disposePreload(_Preload pre) async {
+    pre.fail();
+    await pre.logSub?.cancel();
+    try {
+      await pre.player.dispose();
+    } catch (_) {}
+  }
+
+  /// [pre] becomes the session player ([_adopt]); the full cache pins
+  /// replace its small ones.
+  Future<bool> _promote(_Preload pre) async {
+    await pre.opened.future;
+    final old = _player;
+    if (!identical(_pre, pre) || old == null) return false;
+    _pre = null;
+    if (pre.failed) {
+      unawaited(_disposePreload(pre));
+      return false;
+    }
+    await pre.logSub?.cancel();
+    if (!pre.ready.isCompleted) pre.ready.complete(true);
+    final p = pre.player;
+    await _adopt(p, pre.video, ytdl: pre.ytdl, ytdlRaw: pre.ytdlRaw);
+    try {
+      await _pin('mute', 'no', p);
+      await _pinBufferProps(p);
+    } catch (e) {
+      debugPrint('promoted player settings: $e');
+    }
+    return true;
+  }
+
+  // The current player has had media opened in it (one fresh from [init]
+  // has not, so the first open after join or Reload video uses it).
+  bool _held = false;
+
+  // The last replaced player until it is disposed: a fresh player waits
+  // for it, so at most one old player lingers.
+  Future<void> _retiring = Future.value();
+
+  /// Replaces the current player with a fresh one set up like [init]'s
+  /// (pins, hwdec, volume, yt-dlp hook, shaders, observers), its video
+  /// output ready before the view swaps to it when the view is up. True
+  /// once it is the session player.
+  Future<bool> _freshPlayer() async {
+    await _retiring;
+    final old = _player;
+    if (old == null) return false;
+    final p = _newPlayer(bufferSize: maxBytes, logLevel: MPVLogLevel.warn); // see [logLevel]
+    VideoController? video;
+    var ytdl = false, ytdlRaw = '';
+    try {
+      pinMismatches.clear();
+      await _pinBufferProps(p);
+      await _pin('volume-max', '$maxVolume', p);
+      final path = _ytdlPath;
+      if (path != null) {
+        ytdlRaw = await _setYtdl(p, path);
+        ytdl = true;
+      }
+      // The view is up: the new output is created (and its texture
+      // registered) before the view swaps, so the old picture stays until
+      // then. Created by the view instead while the render mode is not
+      // known yet, so the probe hears its GL init ([video]).
+      if (_video != null && renderMode.peek() != RenderMode.unknown) {
+        video = VideoController(p, configuration: VideoControllerConfiguration(hwdec: _hwdecOverride));
+        await video.platform.future;
+      }
+    } catch (e) {
+      debugPrint('fresh player setup: $e');
+    }
+    // Disposed or reloaded meanwhile: that player stays.
+    if (!identical(old, _player)) {
+      try {
+        await p.dispose();
+      } catch (_) {}
+      return false;
+    }
+    await _adopt(p, video, ytdl: ytdl, ytdlRaw: ytdlRaw);
+    return true;
+  }
+
+  /// mpv's yt-dlp hook on [p] (see [useYtDlp]); returns the raw options set.
+  static Future<String> _setYtdl(Player p, String path) async {
+    final dynamic platform = p.platform;
+    await platform?.setProperty('script-opts', 'ytdl_hook-ytdl_path=$path');
+    await platform?.setProperty('ytdl-format', ytdlFormat);
+    final raw = await AppYtDlp.instance.mpvRawOptions();
+    await platform?.setProperty('ytdl-raw-options', raw);
+    return raw;
+  }
+
+  /// [p] becomes the session player (a promoted preload or a fresh
+  /// player): log, marks and track observers move over, the view swaps to
+  /// its video output ([generation]), volume and shaders carry over, and
+  /// the old player is paused and disposed once the view let go of its
+  /// texture (as in [dispose]).
+  Future<void> _adopt(SyncPlayer p, VideoController? video, {required bool ytdl, String ytdlRaw = ''}) async {
+    final old = _player!;
+    final volume = old.state.volume;
+    await _logSub?.cancel();
+    for (final sub in _timeSubs) {
+      await sub.cancel();
+    }
+    _timeSubs.clear();
+    _player = p;
+    _video = video;
+    _held = true;
+    _ytdlSetOn = ytdl ? p : null;
+    _ytdlRaw = ytdlRaw;
+    _chapterJson = '';
+    _httpError = null;
+    _loadErrorSent = false;
+    _shaders = '';
+    final at = p.state.position.inMilliseconds;
+    position.value = Duration(milliseconds: at - at % 250);
+    duration.value = p.state.duration;
+    final ms = p.state.buffer.inMilliseconds;
+    buffered.value = Duration(milliseconds: ms - ms % 250);
+    chapters.value = const [];
+    tracks.value = const [];
+    _logSub = p.stream.log.listen(_onLog);
+    _requestLog(p, logLevel);
+    _watchMarks(p);
+    generation.value++;
+    // Normally stopped already (the coordinator leaves the previous
+    // media first): never two sounds at once.
+    unawaited(old.pause().catchError((_) {}));
+    try {
+      await p.setVolume(volume);
+    } catch (e) {
+      debugPrint('new player volume: $e');
+    }
+    unawaited(applyShaders());
+    unawaited(_refreshTracks());
+    _retiring = () async {
+      await _settleUi();
+      try {
+        await old.dispose();
+      } catch (_) {}
+    }();
+  }
+
   Future<void> stop() async {
     if (!_ready) return;
     try {
@@ -654,3 +1056,27 @@ bool pinMatches(String wanted, String got) {
   final a = double.tryParse(wanted), b = double.tryParse(got);
   return a != null && b != null && a == b;
 }
+
+class _Preload {
+  final SyncPlayer player;
+  final String url;
+  final Map<String, String> headers;
+  VideoController? video;
+  StreamSubscription<PlayerLog>? logSub;
+  /// Completes once the media is handed to mpv (or the preload failed).
+  final opened = Completer<void>();
+  bool ytdl = false;
+  String ytdlRaw = '';
+  bool failed = false;
+  final ready = Completer<bool>();
+  _Preload(this.player, this.url, this.headers);
+
+  bool matches(String url, Map<String, String>? headers) =>
+      url == this.url && mapEquals(headers ?? const {}, this.headers);
+
+  void fail() {
+    failed = true;
+    if (!ready.isCompleted) ready.complete(false);
+    if (!opened.isCompleted) opened.complete();
+  }
+}

apps/desktop/lib/src/playback/yt_dlp_app.dart

@@ -0,0 +1,96 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:path_provider/path_provider.dart';
+import 'package:sync_relay_core/core.dart';
+
+import '../platform/ports/link_resolver.dart';
+
+/// mpv's `ytdl-format` for links every player opens itself.
+const ytdlFormat = 'bv*[height<=1080]+ba/b';
+
+/// yt-dlp's `--sub-langs` for mpv's hook (its default is `all`), without
+/// Bilibili's danmaku: an XML comment feed served raw-deflate, which
+/// ffmpeg fails to inflate on every read (a warning each time) while the
+/// video waits on it.
+const ytdlSubLangs = 'all,-danmaku';
+
+/// The app's yt-dlp (see [YtDlp]): in the app-support folder, shared with
+/// the hosted server. [probe] remembers what pasted links are for a while,
+/// so the Link preview and the swap ask once.
+class AppYtDlp implements LinkResolver {
+  static final instance = AppYtDlp();
+
+  /// [ytDlp]: a given one (tests); default in the app-support folder.
+  AppYtDlp([YtDlp? ytDlp]) : _ytDlp = ytDlp == null ? null : Future.value(ytDlp);
+
+  Future<YtDlp>? _ytDlp;
+  @override
+  Future<YtDlp> get ytDlp => _ytDlp ??= () async {
+        final base = await getApplicationSupportDirectory();
+        return YtDlp(dir(base.path));
+      }();
+
+  static String dir(String appSupport) => '$appSupport${Platform.pathSeparator}yt-dlp';
+
+  /// Gets yt-dlp ready in the background (download on first run, a daily
+  /// update check afterwards).
+  @override
+  void warmUp() => unawaited(ytDlp.then((y) => y.ensure()).catchError((_) => null));
+
+  /// mpv's `ytdl-raw-options`: [ytdlSubLangs] and the cookies in the
+  /// yt-dlp folder (see [YtDlpCookies]).
+  @override
+  Future<String> mpvRawOptions() async {
+    const subs = 'sub-langs=%${ytdlSubLangs.length}%$ytdlSubLangs';
+    try {
+      final cookies = (await ytDlp).cookies.mpvRawOptions();
+      return cookies.isEmpty ? subs : '$subs,$cookies';
+    } catch (_) {
+      return subs;
+    }
+  }
+
+  final _probes = <String, ({DateTime at, DateTime until, Future<LinkProbe> f})>{};
+  static const _probeTtl = Duration(minutes: 10);
+
+  /// What [url] is, from memory while it is kept (10 minutes from when it
+  /// was probed; [keep] keeps it longer, for Up next's first item, which
+  /// is probed again before that runs out). [fresh] probes again: the
+  /// remembered result stays until the new one is in, and stays when the
+  /// new one fails.
+  @override
+  Future<LinkProbe> probe(String url, {Duration keep = _probeTtl, bool fresh = false}) {
+    final now = DateTime.now();
+    _probes.removeWhere((_, v) => now.isAfter(v.until));
+    final hit = _probes[url];
+    if (hit != null && !fresh) {
+      final longer = hit.at.add(keep);
+      if (longer.isAfter(hit.until)) _probes[url] = (at: hit.at, until: longer, f: hit.f);
+      return hit.f;
+    }
+    final f = ytDlp.then((y) => probeLink(Uri.parse(url), ytDlp: y));
+    final until = now.add(keep);
+    if (hit == null) {
+      _probes[url] = (at: now, until: until, f: f);
+      f.catchError((Object _) {
+        if (_probes[url]?.f == f) _probes.remove(url);
+        return LinkProbe.file(Uri(), -1);
+      });
+    } else {
+      f.then<void>((_) {
+        _probes[url] = (at: now, until: until, f: f);
+      }, onError: (Object _) {});
+    }
+    return f;
+  }
+
+  /// [url] no longer needs keeping longer: back to the usual 10 minutes.
+  @override
+  void release(String url) {
+    final hit = _probes[url];
+    if (hit == null) return;
+    final usual = hit.at.add(_probeTtl);
+    if (usual.isBefore(hit.until)) _probes[url] = (at: hit.at, until: usual, f: hit.f);
+  }
+}

apps/desktop/lib/src/queue/queue_controller.dart

@@ -0,0 +1,803 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+import 'dart:math';
+
+import 'package:flutter/foundation.dart';
+import 'package:signals/signals_flutter.dart';
+import 'package:sync_relay_core/core.dart';
+
+import '../files/name_parser.dart';
+import '../files/thumbnails.dart';
+import '../jellyfin/accounts.dart';
+import '../jellyfin/format.dart' show pickFor;
+import '../jellyfin/session_media.dart';
+import '../screens/home/picked_media.dart';
+import '../session/app_events.dart' show AddedToUpNext;
+import '../session/media_art.dart';
+import '../session/session_coordinator.dart';
+import '../state/settings.dart';
+import '../sync/avatar_cache.dart';
+import 'queue_logic.dart';
+
+// Up next on this client (see ARCHITECTURE.md "Up next"): the server's
+// queue as signals, adding to it (probed, with a picture), the end-of-media
+// countdown for its first item, putting an item up when this app is the
+// one that can, and keeping that item ready.
+
+/// The end-of-media card for the first Up next item. [secondsLeft] null:
+/// no countdown here (auto-advance off, cancelled, or another app puts
+/// it up), the card offers Play now only.
+class UpNextCountdown {
+  final int mediaId;
+  final QueueItem item;
+  final int? secondsLeft;
+  const UpNextCountdown({required this.mediaId, required this.item, this.secondsLeft});
+}
+
+/// The first item's readiness on this app.
+enum WarmState { idle, warming, ready, failed }
+
+class QueueController {
+  final SessionCoordinator coord;
+  QueueController(this.coord);
+
+  /// Queued items' pictures by hash, from `/i/`.
+  late final PictureCache thumbs = PictureCache(coord.connection.client,
+      route: 'i', keep: RelayConstants.maxQueueItems + 8, live: (s) => [for (final q in s.queue) q.thumb]);
+
+  /// Up next, in order (empty when nothing is queued or not in a server).
+  late final Computed<List<QueueItem>> items =
+      computed(() => coord.serverState.value?.queue ?? const <QueueItem>[]);
+
+  final countdown = signal<UpNextCountdown?>(null);
+
+  /// The first item's id and how ready it is here (null: nothing to get
+  /// ready on this app).
+  final warm = signal<({String id, WarmState state})?>(null);
+
+  /// The natural continuation of what plays: the next episodes of the
+  /// Jellyfin series (not queued; shown greyed under Up next).
+  final continuation = signal<List<EpisodeLink>>(const []);
+
+  /// The mediaId whose continuation was cleared here.
+  final _hiddenFor = signal(-1);
+
+  /// The queue popover is open: the Up next button holds the controls up.
+  final popoverOpen = signal(false);
+
+  // What adder-only items stand for, by their key (a link passed on from
+  // here, a file here). Never leaves this app.
+  final Map<String, ({PickedMedia pick, DateTime at})> _local = {};
+  final Map<String, DateTime> _performing = {};
+  final Set<String> _skipped = {};
+  int _cancelledFor = -1;
+  Timer? _timer;
+  bool _attached = false;
+  String _continuationFor = '';
+  final _random = Random.secure();
+
+  String get _me => coord.connection.memberId;
+
+  void attach() {
+    if (_attached) return;
+    _attached = true;
+    coord.connection.states.listen(_onState);
+    effect(() {
+      final next = coord.nextEpisode.value;
+      final plan = coord.jellyfinPlan.value;
+      unawaited(_loadContinuation(next, plan));
+    });
+    // The continuation and the state decide what to get ready; the media
+    // playing having started (or sitting out) lets the preload go.
+    effect(() {
+      shownContinuation.value;
+      coord.settledMediaId.value;
+      coord.selfAway.value;
+      final r = coord.serverState.value;
+      untracked(() => _warm(r));
+    });
+  }
+
+  // ------------------------------------------------------------- adding
+
+  /// Adds [pick] to Up next (at the end, or with [next] right after what
+  /// plays). A link is probed first and refused like Put it up when it
+  /// will not play. Returns an error text, or null when sent.
+  Future<String?> add(PickedMedia pick, {bool next = false}) async {
+    coord.markInput();
+    if (coord.serverState.peek() == null) return 'not in a server';
+    if (coord.stateStale.peek()) return 'reconnecting — add it again once back';
+    if (items.peek().length >= RelayConstants.maxQueueItems) {
+      return 'Up next is full (${RelayConstants.maxQueueItems} items)';
+    }
+    final ({QueueItem item, Uint8List? thumb}) built;
+    try {
+      final b = await _build(pick);
+      if (b is String) return b;
+      built = b as ({QueueItem item, Uint8List? thumb});
+    } catch (e) {
+      return "couldn't add it: $e";
+    }
+    final item = built.item;
+    if (item.key.isNotEmpty) _local[item.key] = (pick: pick, at: DateTime.now());
+    final thumb = built.thumb;
+    coord.connection.sendQueue(QueueIntent.add(item, next: next, thumb: thumb == null ? '' : base64Encode(thumb)));
+    coord.notify(AddedToUpNext(item.title));
+    return null;
+  }
+
+  /// A continuation episode becomes an Up next item.
+  Future<String?> promote(EpisodeLink e) => add(e.pick);
+
+  /// The item, or an error text.
+  Future<Object> _build(PickedMedia pick) async {
+    switch (pick) {
+      case JellyfinMedia():
+        final accounts = coord.jellyfin;
+        if (accounts.account(pick.serverId) == null) return 'that Jellyfin server is not linked any more';
+        if (accounts.statusOf(pick.serverId) == JellyfinAccountStatus.expired) {
+          return 'Jellyfin sign-in expired — reconnect it in Settings → Jellyfin & integrations';
+        }
+        final client = accounts.clientFor(pick.serverId);
+        final thumb = client == null ? null : await _jellyfinThumb(client, pick.itemId);
+        return (
+          item: QueueItem(
+            media: mediaForPick(pick),
+            how: QueueHow.jellyfin,
+            title: pick.title,
+            sub: pick.subtitle,
+            duration: (pick.runtime?.inMilliseconds ?? 0) / 1000,
+          ),
+          thumb: thumb,
+        );
+      case FileMedia(:final path):
+        final file = File(path);
+        if (!await file.exists()) return 'file not found — check the path';
+        final name = pick.label;
+        final parsed = parseReleaseName(name);
+        final shot = await thumbnailFor(path);
+        Uint8List? thumb;
+        if (shot != null) {
+          try {
+            final bytes = await File(shot.imagePath).readAsBytes();
+            if (bytes.length <= RelayConstants.maxPosterBytes) thumb = bytes;
+          } catch (_) {}
+        }
+        final ep = [
+          if (parsed.season != null) 'S${parsed.season}',
+          if (parsed.episode != null) 'E${parsed.episode}',
+        ].join();
+        return (
+          item: QueueItem(
+            media: HelloMedia(name: name, size: await file.length(), duration: 0),
+            how: QueueHow.file,
+            title: parsed.series.trim().isEmpty ? name : parsed.series.trim(),
+            sub: ep,
+            duration: (shot?.duration.inMilliseconds ?? 0) / 1000,
+            key: _newKey(),
+          ),
+          thumb: thumb,
+        );
+      case LinkMedia(:final url, :final anyway):
+        // Alone, a link plays direct: there is nobody to pass it on to.
+        final relay = coord.solo ? LinkRelay.direct : pick.relay;
+        final linked = await mediaForLink(coord.jellyfin, url);
+        final ref = linked.jellyfin;
+        if (ref != null) {
+          return (
+            item: QueueItem(
+                media: HelloMedia(name: linked.name, size: 0, duration: 0, jellyfin: ref),
+                how: QueueHow.jellyfin,
+                title: ref.title.isEmpty ? linked.name : ref.title,
+                sub: ref.subtitle ?? '',
+                duration: ref.runtimeSecs ?? 0),
+            thumb: null,
+          );
+        }
+        LinkProbe? probe;
+        String? probeError;
+        try {
+          probe = await coord.ytDlp.probe(url).timeout(const Duration(seconds: 45));
+        } catch (e) {
+          probeError = '$e';
+        }
+        final problem = probe == null ? playErrorText(probeError ?? '') : probe.problem;
+        if (problem != null && !anyway) return problem;
+        if (relay == LinkRelay.me) {
+          if (probe == null) return problem ?? "couldn't reach the site";
+          final relayProblem = probe.relayProblem;
+          if (relayProblem != null) return relayProblem;
+        }
+        if (relay == LinkRelay.server && !coord.serverHasPassword) return 'server fetch needs a server password';
+        if (relay == LinkRelay.server && probe != null && probe.isPage && probe.info != null) {
+          final relayProblem = probe.relayProblem;
+          if (relayProblem != null) return relayProblem;
+        }
+        final uri = Uri.tryParse(url) ?? Uri();
+        final info = probe?.info;
+        final title = probe?.title ?? linked.name;
+        final site = info == null
+            ? uri.host
+            : (info.uploader.isNotEmpty ? info.uploader : (info.extractor.isNotEmpty ? info.extractor : uri.host));
+        final thumbUrl = info?.thumbnail == null ? null : Uri.tryParse(info!.thumbnail!);
+        final thumb = thumbUrl == null ? null : (await thumbnailArt(thumbUrl))?.poster;
+        final how = switch (relay) {
+          LinkRelay.direct => QueueHow.direct,
+          LinkRelay.server => QueueHow.server,
+          LinkRelay.me => QueueHow.through,
+        };
+        return (
+          item: QueueItem(
+            media: HelloMedia(
+                name: title,
+                size: 0,
+                duration: 0,
+                url: how == QueueHow.through ? null : url,
+                relay: how == QueueHow.server ? const MediaRelay(fetch: true) : null),
+            how: how,
+            title: title,
+            sub: site,
+            duration: info?.duration ?? 0,
+            key: how == QueueHow.through ? _newKey() : '',
+          ),
+          thumb: thumb,
+        );
+    }
+  }
+
+  String _newKey() => [for (var i = 0; i < 12; i++) _random.nextInt(256).toRadixString(16).padLeft(2, '0')].join();
+
+  /// A wide picture of a Jellyfin item: an episode's own still, else the
+  /// item's (or series') thumb or backdrop, else its poster.
+  Future<Uint8List?> _jellyfinThumb(JellyfinClient client, String itemId) async {
+    try {
+      final item = await client.item(itemId).timeout(const Duration(seconds: 10));
+      final ref = (item.kind == JellyfinItemKind.episode ? item.ownImage(JellyfinImageType.primary) : null) ??
+          item.image(JellyfinImageType.thumb) ??
+          item.image(JellyfinImageType.backdrop) ??
+          item.image(JellyfinImageType.primary);
+      if (ref == null) return null;
+      return await fetchImage(
+          client.imageUrl(ref, maxWidth: 480, quality: 80), client.authHeaders, RelayConstants.maxPosterBytes);
+    } catch (e) {
+      debugPrint('queue: no Jellyfin picture for $itemId: $e');
+      return null;
+    }
+  }
+
+  /// [item]'s link as this app may hand it out (Copy link, Open in
+  /// browser): a link everyone opens (it is in the state), or a link this
+  /// app passes on (its adder). Null otherwise: a server-fetched link stays
+  /// with the server, another member's passed-on link with them.
+  String? linkOf(QueueItem item) => switch (item.how) {
+        QueueHow.direct => item.media.url,
+        QueueHow.through when item.by == _me => switch (_local[item.key]?.pick) {
+            LinkMedia(:final url) => url,
+            _ => null,
+          },
+        _ => null,
+      };
+
+  /// [item]'s page on its Jellyfin server, when that server is linked here.
+  String? jellyfinPageOf(QueueItem item) {
+    final ref = item.media.jellyfin;
+    return ref == null ? null : coord.jellyfin.webUrlOf(ref.serverId, ref.itemId);
+  }
+
+  // ------------------------------------------------------------ editing
+
+  void move(String id, int to) {
+    coord.markInput();
+    coord.connection.sendQueue(QueueIntent.move(id, to));
+  }
+
+  void remove(String id) {
+    coord.markInput();
+    coord.connection.sendQueue(QueueIntent.remove(id));
+  }
+
+  /// Plays [id] now: this app puts it up when it is the one that can,
+  /// else it asks the server, and the app that can puts it up.
+  void playNow(String id) {
+    coord.markInput();
+    final r = coord.serverState.peek();
+    final item = r?.queue.where((q) => q.id == id).firstOrNull;
+    if (r == null || item == null) return;
+    if (queuePerformer(item, r.members).id == _me) {
+      _perform(item);
+    } else {
+      coord.connection.sendQueue(QueueIntent.play(id));
+    }
+  }
+
+  /// Plays the first Up next item now.
+  void skip() {
+    final first = items.peek().firstOrNull;
+    if (first != null) playNow(first.id);
+  }
+
+  /// Cancel on the end-of-media card: no countdown here for this media.
+  void cancelCountdown() {
+    final c = countdown.peek();
+    _timer?.cancel();
+    _timer = null;
+    if (c == null) return;
+    _cancelledFor = c.mediaId;
+    countdown.value = UpNextCountdown(mediaId: c.mediaId, item: c.item);
+  }
+
+  /// "Clear": hides the continuation of what plays now (and its next
+  /// episode does not come up by itself).
+  void clearContinuation() {
+    final id = coord.serverState.peek()?.mediaId;
+    if (id != null) _hiddenFor.value = id;
+    if (coord.autoAdvance.peek() != null) coord.cancelAutoAdvance();
+  }
+
+  /// The continuation applies to [mediaId]: nothing is queued and it was
+  /// not cleared.
+  bool continuationShown(int mediaId) =>
+      (coord.serverState.peek()?.queue.isEmpty ?? true) && _hiddenFor.peek() != mediaId;
+
+  /// [continuation] unless cleared for the media playing.
+  late final Computed<List<EpisodeLink>> shownContinuation = computed(() {
+    final id = coord.serverState.value?.mediaId;
+    return id != null && _hiddenFor.value == id ? const <EpisodeLink>[] : continuation.value;
+  });
+
+  // --------------------------------------------------------- per state
+
+  void _onState(StateBroadcast r) {
+    _lastState = r;
+    _prune(r);
+    final queue = r.queue;
+    final play = r.queuePlay;
+    if (play != null) {
+      final item = queue.where((q) => q.id == play).firstOrNull;
+      if (item != null) _bringUp(item, r);
+    }
+    final finished = r.transport == 'finished';
+    if (queue.isNotEmpty && r.media == null) {
+      // Nothing up yet: the first item goes up at once.
+      _bringUp(queue.first, r);
+    } else if (finished && queue.isNotEmpty) {
+      _atEnd(r);
+    } else {
+      if (countdown.peek() != null) _stopCountdown();
+      if (!finished) _cancelledFor = -1;
+    }
+    _warm(r);
+  }
+
+  /// Forgets what no longer matters: performing marks after a minute (a
+  /// swap that never landed may be tried again), local picks no longer
+  /// queued.
+  void _prune(StateBroadcast r) {
+    final now = DateTime.now();
+    _performing.removeWhere((_, at) => now.difference(at) > const Duration(minutes: 1));
+    final keys = {for (final q in r.queue) q.key};
+    _local.removeWhere((k, v) => !keys.contains(k) && now.difference(v.at) > const Duration(minutes: 1));
+    final ids = {for (final q in r.queue) q.id};
+    _skipped.removeWhere((id) => !ids.contains(id));
+  }
+
+  /// [item] should go up now: by this app when it is the one that can;
+  /// nobody can: the lowest member takes it off with the reason.
+  void _bringUp(QueueItem item, StateBroadcast r) {
+    final perf = queuePerformer(item, r.members);
+    if (perf.id == null) {
+      final why = perf.why;
+      if (why != null && queueJanitor(r.members) == _me && _skipped.add(item.id)) {
+        coord.connection.sendQueue(QueueIntent.remove(item.id, why: why));
+      }
+      return;
+    }
+    if (perf.id == _me) _perform(item);
+  }
+
+  /// The media finished with Up next waiting: the card, and with
+  /// auto-advance on the countdown, for its first item.
+  void _atEnd(StateBroadcast r) {
+    // Up next goes before the next episode, even one already counting.
+    if (coord.autoAdvance.peek() != null) coord.cancelAutoAdvance();
+    final head = r.queue.first;
+    final perf = queuePerformer(head, r.members);
+    if (perf.id == null && perf.why != null) {
+      // Taken off by [_bringUp]'s rule; the next state shows the next one.
+      _bringUp(head, r);
+      return;
+    }
+    final c = countdown.peek();
+    if (c != null && c.mediaId == r.mediaId) {
+      if (c.item.id != head.id || c.item.thumb != head.thumb) {
+        countdown.value = UpNextCountdown(mediaId: c.mediaId, item: head, secondsLeft: c.secondsLeft);
+      }
+      return;
+    }
+    final auto = AppSettings.instance.autoAdvance.peek() && _cancelledFor != r.mediaId;
+    countdown.value = UpNextCountdown(mediaId: r.mediaId, item: head, secondsLeft: auto ? autoAdvanceSecs : null);
+    _timer?.cancel();
+    _timer = auto ? Timer.periodic(const Duration(seconds: 1), (_) => _tick()) : null;
+  }
+
+  void _tick() {
+    final c = countdown.peek();
+    final r = coord.serverState.peek();
+    final left = c?.secondsLeft;
+    if (c == null || left == null || r == null || r.mediaId != c.mediaId || r.transport != 'finished') {
+      _stopCountdown();
+      return;
+    }
+    if (left > 1) {
+      countdown.value = UpNextCountdown(mediaId: c.mediaId, item: c.item, secondsLeft: left - 1);
+      return;
+    }
+    _timer?.cancel();
+    _timer = null;
+    _cancelledFor = c.mediaId;
+    countdown.value = UpNextCountdown(mediaId: c.mediaId, item: c.item);
+    // Decided on the latest state: only the app that can puts it up.
+    final head = r.queue.firstOrNull;
+    if (head != null && queuePerformer(head, r.members).id == _me) _perform(head);
+  }
+
+  void _stopCountdown() {
+    _timer?.cancel();
+    _timer = null;
+    countdown.value = null;
+  }
+
+  /// Puts [item] up from here (once per item while it is in flight).
+  /// When it cannot play after all, it is taken off with the reason.
+  void _perform(QueueItem item) {
+    if (_performing.containsKey(item.id)) return;
+    _performing[item.id] = DateTime.now();
+    unawaited(() async {
+      String? error;
+      try {
+        error = await _swapTo(item);
+      } catch (e) {
+        error = '$e';
+      }
+      if (error != null) {
+        debugPrint('queue: ${item.id} cannot go up: $error');
+        coord.connection.sendQueue(QueueIntent.remove(item.id, why: "couldn't play it ($error)"));
+      }
+    }());
+  }
+
+  Future<String?> _swapTo(QueueItem item) async {
+    switch (item.how) {
+      case QueueHow.jellyfin:
+        final ref = item.media.jellyfin;
+        final pick = ref == null ? null : pickForRef(coord.jellyfin, ref);
+        if (pick == null) return 'no Jellyfin account here for it';
+        coord.swapJellyfin(pick, queueId: item.id);
+        return null;
+      case QueueHow.direct:
+        final url = item.media.url;
+        if (url == null) return 'no link';
+        // Each viewer opens it: one computer's probe does not decide.
+        return coord.swapLink(url, relay: LinkRelay.direct, anyway: true, queueId: item.id);
+      case QueueHow.server:
+        coord.swapQueued(HelloMedia(name: item.title, size: 0, duration: 0, relay: const MediaRelay(fetch: true)),
+            item.id,
+            art: thumbs.bytesFor(item.thumb));
+        return null;
+      case QueueHow.through:
+      case QueueHow.file:
+        final local = _local[item.key];
+        if (local == null) return "it isn't on this computer any more";
+        // Only this app can pass it on, and a member sitting out has
+        // nothing open: back first.
+        if (coord.selfAway.peek()) coord.joinBack();
+        return coord.swapPicked(local.pick, queueId: item.id);
+    }
+  }
+
+  // ------------------------------------------------------------ warming
+
+  /// How long a warm result is kept, when it is resolved again, and when a
+  /// failed one is tried again.
+  static const _warmKeep = Duration(minutes: 35);
+  static const _warmRefresh = Duration(minutes: 30);
+  static const _warmRetry = Duration(minutes: 2);
+
+  String _warmKey = '';
+  String? _warmUrl;
+  Timer? _warmTimer;
+  int _warmGen = 0;
+  // What the preload player should hold once the media playing has
+  // started (null: nothing); [_preloadFresh]: open it again (a link's
+  // refresh).
+  ({String url, Map<String, String>? headers})? _preloadWant;
+  bool _preloadFresh = false;
+  String _preloadKey = '';
+  bool _preloadBusy = false;
+  bool _preloadOk = true;
+  int _preloadGen = 0;
+  StateBroadcast? _lastState;
+
+  bool _ownAccount(String serverId) =>
+      coord.jellyfin.account(serverId) != null && coord.jellyfin.statusOf(serverId) != JellyfinAccountStatus.expired;
+
+  /// What this app gets ready: Up next's first item, else (Up next empty)
+  /// the first continuation episode (only here when this app plays the
+  /// series with its own account). Every app does, each its own copy (see
+  /// [_WarmTarget]); while sitting out only the probe of a link this app
+  /// puts up (its swap reads it). Null: nothing.
+  _WarmTarget? _warmTarget(StateBroadcast? r) {
+    final t = _warmTargetHere(r);
+    if (t == null || !coord.selfAway.peek()) return t;
+    return t.probe == null ? null : _WarmTarget(t.id, probe: t.probe);
+  }
+
+  _WarmTarget? _warmTargetHere(StateBroadcast? r) {
+    if (r == null) return null;
+    final head = r.queue.firstOrNull;
+    if (head != null) {
+      final performer = queuePerformer(head, r.members).id == _me;
+      final local = _local[head.key]?.pick;
+      // The server's warm relay of the item, once bytes can flow: what
+      // everyone without their own copy preloads.
+      final relay = head.media.relay;
+      final warmUrl = relay != null && relay.live ? coord.warmRelayUrl(head, relay) : null;
+      switch (head.how) {
+        case QueueHow.jellyfin:
+          final ref = head.media.jellyfin;
+          if (ref == null) return null;
+          if (_ownAccount(ref.serverId)) return _WarmTarget(head.id, ref: ref);
+          // No account here: the server's login passes it on (`/j`), else
+          // the warm relay a member with an account feeds.
+          final open = r.relayNext ? coord.jellyfinRelayUrl(ref) : warmUrl;
+          return open == null ? null : _WarmTarget(head.id, open: open);
+        case QueueHow.direct:
+          final url = head.media.url;
+          if (url == null) return null;
+          return _WarmTarget(head.id, probe: performer ? url : null, open: url);
+        case QueueHow.through:
+          // Only its adder has the link (and feeds the warm relay).
+          if (!performer) return warmUrl == null ? null : _WarmTarget(head.id, open: warmUrl);
+          final url = local is LinkMedia ? local.url : null;
+          return _WarmTarget(head.id, probe: url, open: url);
+        case QueueHow.file:
+          if (!performer) return warmUrl == null ? null : _WarmTarget(head.id, open: warmUrl);
+          // The host's own file plays from its `/m` URL once it is up.
+          return _WarmTarget(head.id, open: local is FileMedia && coord.hostFile == null ? local.path : null);
+        case QueueHow.server:
+          // The server fetches it into its warm relay; everyone preloads that.
+          if (warmUrl != null) return _WarmTarget(head.id, open: warmUrl);
+          return performer ? _WarmTarget(head.id) : null;
+      }
+    }
+    final next = shownContinuation.peek().firstOrNull;
+    if (next == null) return null;
+    return _WarmTarget('next:${next.item.id}', ref: mediaForPick(next.pick).jellyfin);
+  }
+
+  /// Keeps the one item that plays next ready on this app, so a skip or
+  /// the end of what plays starts it at once: a link probed when this app
+  /// puts it up (`AppYtDlp.probe`, kept while it stays first), a Jellyfin
+  /// item resolved with this app's account
+  /// ([SessionCoordinator.warmJellyfin]), and then opened in the hidden
+  /// preload player ([SessionCoordinator.preloadMedia]) once the media
+  /// playing has started. Done as soon as it is first, again before that
+  /// runs out, dropped when it is no longer first.
+  void _warm(StateBroadcast? r) {
+    _feedWarm(r);
+    final t = _warmTarget(r);
+    final key = t?.key ?? '';
+    if (key != _warmKey) {
+      _dropWarm(r);
+      _warmKey = key;
+      if (t == null) {
+        if (warm.peek() != null) warm.value = null;
+      } else if (t.empty) {
+        warm.value = (id: t.id, state: WarmState.ready);
+      } else {
+        warm.value = (id: t.id, state: WarmState.warming);
+        _resolveWarm(t, fresh: false);
+      }
+    }
+    _syncPreload(r);
+  }
+
+  // The warm relay this app feeds (`<queue id>|<token>`), started once.
+  String _fedWarm = '';
+
+  /// Feeds the server's warm relay of Up next's first item from here when
+  /// it names this member as its source (a link passed on, a file), or a
+  /// Jellyfin item this app puts up with its own account when the server
+  /// asks for a source; see [SessionCoordinator.feedWarm]. The server
+  /// drops the relay (and with it the source) once the item is no longer
+  /// first.
+  void _feedWarm(StateBroadcast? r) {
+    final head = r?.queue.firstOrNull;
+    final relay = head?.media.relay;
+    if (r == null || head == null || relay == null || relay.fetch) return;
+    final key = '${head.id}|${coord.connection.token}';
+    if (key == _fedWarm) return;
+    switch (head.how) {
+      case QueueHow.through:
+      case QueueHow.file:
+        if (relay.source != _me) return;
+        final pick = _local[head.key]?.pick;
+        if (pick is FileMedia) {
+          _fedWarm = key;
+          coord.feedWarm(head.id, RelayMedia.single(FileRelayBytes(File(pick.path))));
+        } else if (pick is LinkMedia) {
+          _fedWarm = key;
+          unawaited(() async {
+            try {
+              // The probe [_resolveWarm] keeps: no second yt-dlp run.
+              final probe = await coord.ytDlp.probe(pick.url, keep: _warmKeep).timeout(const Duration(seconds: 60));
+              final y = await coord.ytDlp.ytDlp;
+              if (_fedWarm != key) return;
+              coord.feedWarm(head.id, LinkRelayMedia(Uri.parse(pick.url), ytDlp: y, probe: probe));
+            } catch (e) {
+              debugPrint('queue: feeding ${head.id}: $e');
+            }
+          }());
+        }
+      case QueueHow.jellyfin:
+        final ref = head.media.jellyfin;
+        if (ref == null || (relay.source.isNotEmpty && relay.source != _me)) return;
+        if (queuePerformer(head, r.members).id != _me) return;
+        // Resolved with this app's account by [_resolveWarm].
+        final w = coord.warmJellyfin;
+        if (w == null || !sameJellyfinItem(w.ref, ref)) return;
+        _fedWarm = key;
+        coord.feedWarm(
+            head.id, RelayMedia.single(HttpRelayBytes(Uri.parse(w.plan.url), headers: w.plan.headers)));
+      case QueueHow.direct:
+      case QueueHow.server:
+        return;
+    }
+  }
+
+  void _dropWarm(StateBroadcast? r) {
+    _warmTimer?.cancel();
+    _warmTimer = null;
+    _warmGen++;
+    _preloadWant = null;
+    final url = _warmUrl;
+    _warmUrl = null;
+    if (url != null) coord.ytDlp.release(url);
+    // Kept while it is what just went up: that open takes it.
+    final w = coord.warmJellyfin;
+    if (w != null && !sameJellyfinItem(w.ref, refOfStateMedia(r?.media))) coord.warmJellyfin = null;
+  }
+
+  void _resolveWarm(_WarmTarget t, {required bool fresh}) {
+    final gen = ++_warmGen;
+    unawaited(() async {
+      var ok = true;
+      ({String url, Map<String, String>? headers})? open;
+      try {
+        final probe = t.probe, ref = t.ref, url = t.open;
+        if (probe != null) {
+          _warmUrl = probe;
+          final p = await coord.ytDlp.probe(probe, keep: _warmKeep, fresh: fresh).timeout(const Duration(seconds: 60));
+          ok = p.problem == null;
+        }
+        if (ref != null) {
+          final plan = await resolveJellyfinRef(coord.jellyfin, ref, relay: false, relayUrl: null);
+          if (gen != _warmGen) return;
+          ok = plan is OwnPlay;
+          if (plan is OwnPlay) {
+            coord.warmJellyfin = (ref: ref, plan: plan, until: DateTime.now().add(_warmKeep));
+            open = (url: plan.url, headers: plan.headers);
+            _feedWarm(coord.serverState.peek());
+          }
+        } else if (url != null && ok) {
+          open = (url: url, headers: null);
+        }
+      } catch (e) {
+        ok = false;
+        debugPrint('queue: getting ${t.id} ready: $e');
+      }
+      if (gen != _warmGen) return;
+      _preloadWant = ok ? open : null;
+      // A refresh opens a link again (a page's stream URLs expire); the
+      // same Jellyfin stream stays as it is.
+      _preloadFresh = fresh && ok && t.ref == null && open != null;
+      final waits = ok && open != null && coord.playback.preloadEnabled;
+      warm.value = (id: t.id, state: !ok ? WarmState.failed : (waits ? WarmState.warming : WarmState.ready));
+      _syncPreload(coord.serverState.peek());
+      _warmTimer = Timer(ok ? _warmRefresh : _warmRetry, () => _resolveWarm(t, fresh: true));
+    }());
+  }
+
+  /// Puts [_preloadWant] in the preload player, or drops what it holds;
+  /// only once the media playing has started (its own open goes first,
+  /// and a preload a swap is about to take is never replaced before), at
+  /// once while sitting out (nothing preloads then).
+  void _syncPreload(StateBroadcast? r) {
+    // The newest state seen here: the coordinator's lags behind while the
+    // same `state` is still being handed to it.
+    final seen = _lastState;
+    if (r == null || (seen != null && seen.mediaId > r.mediaId)) r = seen;
+    if (r == null) return;
+    final out = coord.selfAway.peek();
+    if (!out && r.media != null && coord.settledMediaId.peek() != r.mediaId) return;
+    final want = out ? null : _preloadWant;
+    final playback = coord.playback;
+    if (want == null) {
+      _preloadKey = '';
+      _preloadGen++;
+      if (playback.preloadUrl != null) unawaited(playback.dropPreload());
+      return;
+    }
+    if (!playback.preloadEnabled) return;
+    final key = '${want.url}|${want.headers}';
+    final fresh = _preloadFresh;
+    // Asked for already: in flight, there, or failed (tried again with the
+    // next refresh). One that went away (Reload video) is asked again.
+    if (!fresh && key == _preloadKey && (_preloadBusy || !_preloadOk || playback.preloadUrl == want.url)) return;
+    _preloadFresh = false;
+    _preloadKey = key;
+    _preloadBusy = true;
+    final gen = ++_preloadGen;
+    final id = warm.peek()?.id;
+    unawaited(coord.preloadMedia(want.url, headers: want.headers, fresh: fresh).then((ok) {
+      if (gen != _preloadGen) return;
+      _preloadBusy = false;
+      _preloadOk = ok;
+      // A preload that fails leaves the usual open: nothing to say.
+      if (!ok) debugPrint('queue: preload of $id failed');
+      final w = warm.peek();
+      if (w != null && w.id == id && w.state == WarmState.warming) {
+        warm.value = (id: w.id, state: WarmState.ready);
+      }
+    }));
+  }
+
+  // -------------------------------------------------------- continuation
+
+  /// The next few episodes after the one playing (own account only).
+  Future<void> _loadContinuation(EpisodeLink? next, JellyfinPlan? plan) async {
+    if (next == null || plan is! OwnPlay) {
+      _continuationFor = '';
+      if (continuation.peek().isNotEmpty) continuation.value = const [];
+      return;
+    }
+    final key = '${plan.account.serverId}/${next.item.id}';
+    if (key == _continuationFor) return;
+    _continuationFor = key;
+    continuation.value = [next];
+    final seriesId = next.item.seriesId;
+    if (seriesId == null) return;
+    try {
+      final list = await coord.jellyfin.cached(
+          plan.account.serverId, 'episodes:$seriesId', () => plan.client.episodes(seriesId));
+      if (_continuationFor != key) return;
+      final more = [next];
+      var at = next.item;
+      while (more.length < 4) {
+        final after = episodeAfter(list, at.id);
+        if (after == null) break;
+        more.add(EpisodeLink(after, pickFor(plan.account, after)));
+        at = after;
+      }
+      continuation.value = more;
+    } catch (e) {
+      debugPrint('queue: continuation of $seriesId: $e');
+    }
+  }
+}
+
+/// What [QueueController] gets ready for one item on this app: [probe] a
+/// link (the app that puts it up), resolve [ref] with this app's own
+/// account, and preload [open] (or the resolved stream). None of it:
+/// nothing to do here, and it is ready ([empty]).
+class _WarmTarget {
+  final String id;
+  final String? probe;
+  final JellyfinRef? ref;
+  final String? open;
+  const _WarmTarget(this.id, {this.probe, this.ref, this.open});
+
+  bool get empty => probe == null && ref == null && open == null;
+  String get key => '$id|$probe|$open|${ref?.serverId}/${ref?.itemId}/${ref?.mediaSourceId}';
+}

apps/desktop/lib/src/queue/queue_logic.dart

@@ -0,0 +1,80 @@
+import 'package:sync_relay_core/core.dart';
+
+import '../jellyfin/session_media.dart' show compareMemberIds;
+import '../session/party.dart' show isPresent;
+
+// Who puts an Up next item up. Pure: only what every client sees in
+// `state` decides, so all clients agree without a wire message (like the
+// Jellyfin auto-advance swapper).
+
+/// Who puts [item] up: [id] a member id; null with [why] when nobody here
+/// can (the item is skipped), null without [why] when nobody is around
+/// right now (nothing happens).
+typedef QueuePerformer = ({String? id, String? why});
+
+/// - A link passed on by its adder, or the adder's file: only the adder
+///   (their app has the file, the cookies). Gone (disconnected, in its
+///   grace): it waits for them; left for good: skipped.
+/// - Jellyfin: the adder when it plays that server with its own account,
+///   else the lowest member id that does (`jf[serverId] == true`,
+///   present: `in` or joining). Nobody: skipped.
+/// - A link everyone opens, or one the server fetches: the adder when
+///   present, else the lowest present member id.
+QueuePerformer queuePerformer(QueueItem item, List<MemberView> members) {
+  MemberView? adder;
+  for (final m in members) {
+    if (m.id == item.by) adder = m;
+  }
+  bool active(MemberView m) => isPresent(m);
+  if (item.how.adderOnly) {
+    if (adder == null) return (id: null, why: '${_name(item)} left');
+    if (adder.presence == Presence.gone) return (id: null, why: null);
+    return (id: adder.id, why: null);
+  }
+  final ref = item.media.jellyfin;
+  if (item.how == QueueHow.jellyfin && ref != null) {
+    bool can(MemberView m) => active(m) && m.jf[ref.serverId] == true;
+    if (adder != null && can(adder)) return (id: adder.id, why: null);
+    final id = autoAdvanceLowest(members.where(can));
+    return id == null ? (id: null, why: 'nobody here has that Jellyfin server') : (id: id, why: null);
+  }
+  if (adder != null && active(adder)) return (id: adder.id, why: null);
+  return (id: autoAdvanceLowest(members.where(active)), why: null);
+}
+
+String _name(QueueItem item) => item.byName.isEmpty ? 'who added it' : item.byName;
+
+/// The lowest member id of [members] ("m2" before "m10"), or null.
+String? autoAdvanceLowest(Iterable<MemberView> members) {
+  final ids = [for (final m in members) m.id]..sort(compareMemberIds);
+  return ids.isEmpty ? null : ids.first;
+}
+
+/// Who takes an item nobody can put up off the queue (`remove` with why):
+/// the lowest member id that is connected (not gone).
+String? queueJanitor(List<MemberView> members) =>
+    autoAdvanceLowest(members.where((m) => m.presence != Presence.gone));
+
+/// How [item] plays, in a few words for its row: "through Foxyz" (you:
+/// "through you"), "server fetches", "everyone fetches", "Jellyfin",
+/// "Foxyz's file".
+String queueHowLabel(QueueItem item, {required String selfId}) {
+  final mine = item.by == selfId && selfId.isNotEmpty;
+  final who = mine ? 'you' : _name(item);
+  return switch (item.how) {
+    QueueHow.through => 'through $who',
+    QueueHow.file => mine ? 'your file' : "$who's file",
+    QueueHow.server => 'server fetches',
+    QueueHow.direct => 'everyone fetches',
+    QueueHow.jellyfin => 'Jellyfin',
+  };
+}
+
+/// "1:23:45" / "23:45" for [secs]; empty when unknown.
+String queueClock(double secs) {
+  if (secs <= 0) return '';
+  final s = secs.round();
+  final h = s ~/ 3600, m = (s % 3600) ~/ 60, r = s % 60;
+  String two(int v) => v.toString().padLeft(2, '0');
+  return h > 0 ? '$h:${two(m)}:${two(r)}' : '$m:${two(r)}';
+}

apps/desktop/lib/src/schedule/anilist.dart

@@ -6,7 +6,6 @@ import 'dart:ui' show Color;
 import 'package:path_provider/path_provider.dart';
 import 'package:sync_relay_core/core.dart';
 
-import '../update/updater.dart' show appVersion;
 
 // AniList airing schedule (public GraphQL, no login): every episode airing
 // in a time range, with covers, banners and popularity; and a title search
@@ -159,7 +158,7 @@ class AniListClient {
         _cacheDir = cacheDir ?? _defaultCacheDir,
         _delay = delay ?? Future<void>.delayed,
         _now = now ?? DateTime.now,
-        userAgent = userAgent ?? 'watch-together/$appVersion';
+        userAgent = userAgent ?? 'Starsync/$appVersion';
 
   final Uri url;
   final Duration memoryTtl;

apps/desktop/lib/src/schedule/animeflow.dart

@@ -5,7 +5,6 @@ import 'dart:io';
 import 'package:sync_relay_core/core.dart';
 
 import '../jellyfin/accounts.dart';
-import '../update/updater.dart' show appVersion;
 
 // AnimeFlow app API: what the media server tracks, has, downloads and was
 // asked for. Authenticated with the user's own Jellyfin access token
@@ -148,13 +147,17 @@ class AnimeFlowLibraryItem {
   final String name;
   /// Set when AnimeFlow tracks it.
   final int? seriesId;
-  /// AniList entry per TVDB season.
+  /// AniList entry per TVDB season (the first, when a season spans more).
   final Map<int, int> anilistIds;
+  /// Every AniList entry per season with its episode run (`anilist_map`):
+  /// a season AniList splits (one cour as two entries) has several rows.
+  final List<AniListRun> anilistMap;
   const AnimeFlowLibraryItem({
     required this.jellyfinSeriesId,
     required this.name,
     this.seriesId,
     this.anilistIds = const {},
+    this.anilistMap = const [],
   });
 
   static AnimeFlowLibraryItem fromJson(Map j) => AnimeFlowLibraryItem(
@@ -165,15 +168,38 @@ class AnimeFlowLibraryItem {
           for (final e in ((j['anilist_ids'] as Map?) ?? const {}).entries)
             if (int.tryParse('${e.key}') case final season? when _int(e.value) != null) season: _int(e.value)!,
         },
+        anilistMap: [
+          for (final r in (j['anilist_map'] as List?) ?? const [])
+            if (r is Map && _int(r['season']) != null && _int(r['anilist_id']) != null)
+              AniListRun(
+                season: _int(r['season'])!,
+                anilistId: _int(r['anilist_id'])!,
+                firstEpisode: _int(r['first_episode']) ?? 1,
+                offset: _int(r['offset']) ?? 0,
+              ),
+        ],
       );
 }
 
+/// One AniList entry's run within a TVDB season: TVDB episode e (from
+/// [firstEpisode] to the next run of that season) is AniList episode
+/// e - [offset].
+class AniListRun {
+  final int season;
+  final int anilistId;
+  final int firstEpisode;
+  final int offset;
+  const AniListRun({required this.season, required this.anilistId, this.firstEpisode = 1, this.offset = 0});
+}
+
 class AnimeFlowEpisode {
   /// 0 = specials.
   final int season;
   final int episode;
   final int? absolute;
   final String? title;
+  /// Date-only: midnight Japan time of the broadcast day. Compare it as a
+  /// Japan day (`sameAirDay` in schedule_model.dart), never a local one.
   final DateTime? airDate;
   /// The AniList entry of this episode's season (one AnimeFlow series may
   /// span several AniList entries).
@@ -184,8 +210,11 @@ class AnimeFlowEpisode {
   final EpisodeStatus status;
   /// 0..1, only while downloading.
   final double? progress;
-  /// Only when failed.
+  /// Why it failed; for a missing one with rejected releases, a
+  /// ready-to-show sentence ("2 release(s) found, rejected: …").
   final String? reason;
+  /// Last search for a monitored, not yet downloaded episode.
+  final DateTime? lastSearchedAt;
 
   const AnimeFlowEpisode({
     required this.season,
@@ -198,6 +227,7 @@ class AnimeFlowEpisode {
     required this.status,
     this.progress,
     this.reason,
+    this.lastSearchedAt,
   });
 
   static AnimeFlowEpisode fromJson(Map j) => AnimeFlowEpisode(
@@ -206,11 +236,14 @@ class AnimeFlowEpisode {
         absolute: _int(j['absolute']),
         title: _str(j['episode_title']),
         airDate: _time(j['air_date']),
-        anilistId: _int(j['anilist_id']),
+        // The episode's own entry (a split season rolls into its sequel),
+        // else the series' one.
+        anilistId: _int(j['episode_anilist_id']) ?? _int(j['anilist_id']),
         anilistEpisode: _int(j['anilist_episode']),
         status: EpisodeStatus.parse(j['status']),
         progress: (j['progress'] as num?)?.toDouble(),
         reason: _str(j['reason']),
+        lastSearchedAt: _time(j['last_searched_at']),
       );
 }
 
@@ -222,7 +255,6 @@ class AnimeFlowScheduleItem {
   final int? anidbId;
   final int? tvdbId;
   final String? jellyfinSeriesId;
-  final bool followed;
 
   const AnimeFlowScheduleItem({
     required this.episode,
@@ -231,7 +263,6 @@ class AnimeFlowScheduleItem {
     this.anidbId,
     this.tvdbId,
     this.jellyfinSeriesId,
-    this.followed = false,
   });
 
   static AnimeFlowScheduleItem fromJson(Map j) => AnimeFlowScheduleItem(
@@ -241,7 +272,6 @@ class AnimeFlowScheduleItem {
         anidbId: _int(j['anidb_id']),
         tvdbId: _int(j['tvdb_id']),
         jellyfinSeriesId: _str(j['jellyfin_series_id']),
-        followed: j['followed'] == true,
       );
 }
 
@@ -270,7 +300,6 @@ class AnimeFlowSeries {
   final String? jellyfinSeriesId;
   final SeriesState state;
   final bool monitored;
-  final bool followed;
   final int episodesTotal;
   final int episodesAvailable;
   final DateTime? nextAirDate;
@@ -286,7 +315,6 @@ class AnimeFlowSeries {
     this.jellyfinSeriesId,
     this.state = SeriesState.releasing,
     this.monitored = false,
-    this.followed = false,
     this.episodesTotal = 0,
     this.episodesAvailable = 0,
     this.nextAirDate,
@@ -302,7 +330,6 @@ class AnimeFlowSeries {
         jellyfinSeriesId: _str(j['jellyfin_series_id']),
         state: SeriesState.parse(j['state']),
         monitored: j['monitored'] == true,
-        followed: j['followed'] == true,
         episodesTotal: _int(j['episodes_total']) ?? 0,
         episodesAvailable: _int(j['episodes_available']) ?? 0,
         nextAirDate: _time(j['next_air_date']),
@@ -447,7 +474,7 @@ class AnimeFlowClient {
         _ownsHttp = http == null,
         _delay = delay ?? Future<void>.delayed,
         _now = now ?? DateTime.now,
-        userAgent = userAgent ?? 'watch-together/$appVersion';
+        userAgent = userAgent ?? 'Starsync/$appVersion';
 
   /// Authenticated with the linked Jellyfin account on the same domain
   /// (see [tokenFor]), looked up on every call so a re-link applies.
@@ -658,10 +685,6 @@ class AnimeFlowClient {
     return AnimeFlowSeries.fromJson(j is Map ? j : const {});
   }
 
-  /// Follow (or unfollow) a series [view].
-  Future<void> setFollowed(int seriesId, bool followed) =>
-      _call(followed ? 'PUT' : 'DELETE', '/series/$seriesId/follow');
-
   /// Titles that can be requested [request].
   Future<List<AnimeFlowSearchHit>> search(String q) async => [
         for (final h in _items(await _call('GET', '/search', query: {'q': q}))) AnimeFlowSearchHit.fromJson(h),

apps/desktop/lib/src/schedule/schedule_model.dart

@@ -12,14 +12,25 @@ enum ScheduleStatus {
   available,
   downloading,
   upcoming,
+  /// AnimeFlow's `missing`: aired, monitored, no release grabbed yet;
+  /// AnimeFlow grabs it by itself once one appears (nothing to request).
+  /// Also an aired episode of a tracked series AnimeFlow has no row for.
   missing,
   failed,
+  /// AnimeFlow does not monitor it: the only status worth a Request.
   unmonitored,
   /// AnimeFlow does not track this series (or is unreachable).
   notTracked,
-  /// Not tracked by AnimeFlow, but the series is on Jellyfin (`/library`):
-  /// the episode may be there; Put it up finds out.
-  inLibrary;
+  /// Not tracked by AnimeFlow, the series is on Jellyfin (`/library`) and
+  /// so is the episode ([confirmOnJellyfin]; [matchSchedule] alone sets
+  /// it from the series).
+  inLibrary,
+  /// Not tracked, the series is on Jellyfin, the episode aired but is not
+  /// there yet.
+  notOnJellyfin,
+  /// Not tracked, the series is on Jellyfin, the episode aired; whether
+  /// it is there is unknown (no linked account, lookup failed).
+  aired;
 
   static ScheduleStatus of(EpisodeStatus s) => switch (s) {
         EpisodeStatus.available => available,
@@ -37,17 +48,26 @@ class ScheduleEntry {
   final ScheduleStatus status;
   /// 0..1 while downloading.
   final double? progress;
-  /// Why it failed.
+  /// Why it failed, or (missing) why the releases found were rejected.
   final String? reason;
+  /// AnimeFlow's last search for it (missing).
+  final DateTime? lastSearchedAt;
   /// AnimeFlow tracks the series.
   final bool tracked;
-  final bool followed;
-  /// AnimeFlow's series id (follow, requests).
+  /// AnimeFlow's series id (requests).
   final int? seriesId;
-  /// The AnimeFlow season of the matched episode (requests).
+  /// The AnimeFlow season of the matched episode (requests); untracked
+  /// on Jellyfin: the TVDB season of the AniList entry.
   final int? season;
+  /// The TVDB episode number in [season]: tracked, AnimeFlow's own;
+  /// untracked on Jellyfin, AniList episode + the `anilist_map` run's
+  /// offset.
+  final int? jellyfinEpisode;
   /// Play target once available.
   final String? jellyfinSeriesId;
+  /// This user's progress on the Jellyfin episode ([confirmOnJellyfin]);
+  /// null when it is not on Jellyfin or was not looked up.
+  final EpisodeWatch? watch;
   /// The series is on Jellyfin (tracked or not).
   bool get onJellyfin => jellyfinSeriesId != null;
 
@@ -56,13 +76,29 @@ class ScheduleEntry {
     required this.status,
     this.progress,
     this.reason,
+    this.lastSearchedAt,
     this.tracked = false,
-    this.followed = false,
     this.seriesId,
     this.season,
+    this.jellyfinEpisode,
     this.jellyfinSeriesId,
+    this.watch,
   });
 
+  ScheduleEntry copyWith({ScheduleStatus? status, EpisodeWatch? watch}) => ScheduleEntry(
+        airing: airing,
+        status: status ?? this.status,
+        progress: progress,
+        reason: reason,
+        lastSearchedAt: lastSearchedAt,
+        tracked: tracked,
+        seriesId: seriesId,
+        season: season,
+        jellyfinEpisode: jellyfinEpisode,
+        jellyfinSeriesId: jellyfinSeriesId,
+        watch: watch ?? this.watch,
+      );
+
   @override
   String toString() => 'ScheduleEntry(${airing.anilistId}#${airing.episode} $status)';
 }
@@ -73,16 +109,63 @@ ScheduleEntry untrackedEntry(Airing a, DateTime now) => ScheduleEntry(
       status: a.airingAt.isAfter(now) ? ScheduleStatus.upcoming : ScheduleStatus.notTracked,
     );
 
-String _day(DateTime d) {
-  final l = d.toLocal();
-  return '${l.year}-${l.month}-${l.day}';
+/// This user's state of a Jellyfin episode (its `UserData`).
+class EpisodeWatch {
+  final bool played;
+  /// 0..1: the resume point of a partly watched episode (0 = none).
+  final double progress;
+  const EpisodeWatch({this.played = false, this.progress = 0});
+
+  @override
+  bool operator ==(Object other) => other is EpisodeWatch && other.played == played && other.progress == progress;
+  @override
+  int get hashCode => Object.hash(played, progress);
+  @override
+  String toString() => 'EpisodeWatch(${played ? 'played' : '$progress'})';
 }
 
+/// One episode Jellyfin has of a series, as the schedule needs it.
+class JellyfinEpisodeRef {
+  final int season;
+  final int episode;
+  /// Jellyfin's date-only premiere date.
+  final DateTime? premiere;
+  final EpisodeWatch watch;
+  const JellyfinEpisodeRef(this.season, this.episode, {this.premiere, this.watch = const EpisodeWatch()});
+}
+
+// Air dates (AnimeFlow's `air_date`, Jellyfin's premiere date) are
+// date-only: the Japanese broadcast day, sent as midnight Japan time (or
+// midnight UTC by older servers). Both land on the right day read as a
+// Japan (UTC+9, no DST) calendar day, never as a local one: midnight JST
+// is the evening before in Europe and America.
+const _jst = Duration(hours: 9);
+
+/// The Japan calendar day of [t].
+DateTime _jstDay(DateTime t) {
+  final j = t.toUtc().add(_jst);
+  return DateTime.utc(j.year, j.month, j.day);
+}
+
+String _dayKey(DateTime d) => '${d.year}-${d.month}-${d.day}';
+
+/// The Japan days whose air date fits a broadcast at [airingAt]: its own
+/// and, for a late-night slot (before 05:00 JST, "25:30"), the evening
+/// before, which listings often give.
+List<DateTime> _airDays(DateTime airingAt) {
+  final j = airingAt.toUtc().add(_jst);
+  final d = DateTime.utc(j.year, j.month, j.day);
+  return [d, if (j.hour < 5) DateTime.utc(j.year, j.month, j.day - 1)];
+}
+
+/// The date-only [airDate] is the broadcast day of [airingAt] (see
+/// [_airDays]).
+bool sameAirDay(DateTime airDate, DateTime airingAt) => _airDays(airingAt).contains(_jstDay(airDate));
+
 class _SeriesRef {
   final int seriesId;
   final String? jellyfinSeriesId;
-  bool followed;
-  _SeriesRef(this.seriesId, this.jellyfinSeriesId, this.followed);
+  _SeriesRef(this.seriesId, this.jellyfinSeriesId);
 }
 
 /// Merges AniList [airings] with AnimeFlow's [schedule] rows and tracked
@@ -98,51 +181,66 @@ List<ScheduleEntry> matchSchedule(
   DateTime? now,
 }) {
   final at = now ?? DateTime.now();
-  // AniList id -> (Jellyfin series, its TVDB season) from /library.
-  final lib = <int, (String, int)>{};
+  // AniList id -> (Jellyfin series, its TVDB season, TVDB - AniList
+  // episode offset) from /library.
+  final lib = <int, (String, int, int)>{};
   for (final item in library) {
     if (item.jellyfinSeriesId.isEmpty) continue;
+    for (final r in item.anilistMap) {
+      lib[r.anilistId] ??= (item.jellyfinSeriesId, r.season, r.offset);
+    }
     for (final e in item.anilistIds.entries) {
-      lib[e.value] ??= (item.jellyfinSeriesId, e.key);
+      lib[e.value] ??= (item.jellyfinSeriesId, e.key, 0);
     }
   }
   final refs = <int, _SeriesRef>{};
   for (final s in series) {
     final id = s.anilistId;
-    if (id != null) refs[id] ??= _SeriesRef(s.seriesId, s.jellyfinSeriesId, s.followed);
+    if (id != null) refs[id] ??= _SeriesRef(s.seriesId, s.jellyfinSeriesId);
   }
+  // AnimeFlow's AniList episode number wins outright: TVDB numbering runs
+  // on across split entries (JoJo S6E4 is "2nd & 3rd STAGE" ep 3), so a TVDB
+  // or absolute number, or an air day, is only a guess for AniList entries
+  // AnimeFlow gives no AniList numbers for.
+  final byAni = <String, AnimeFlowScheduleItem>{};
   final byEp = <String, AnimeFlowScheduleItem>{};
   final byAbs = <String, AnimeFlowScheduleItem>{};
   final byDay = <String, AnimeFlowScheduleItem>{};
+  final numbered = <int>{};
   for (final it in schedule) {
     final e = it.episode, id = e.anilistId;
     if (id == null) continue;
-    final ref = refs[id] ??= _SeriesRef(it.seriesId, it.jellyfinSeriesId, it.followed);
-    if (it.followed) ref.followed = true;
-    // AnimeFlow's AniList episode number first: TVDB numbering can run on
-    // across split cours.
-    if (e.anilistEpisode != null) byEp.putIfAbsent('$id#${e.anilistEpisode}', () => it);
+    refs[id] ??= _SeriesRef(it.seriesId, it.jellyfinSeriesId);
+    if (e.anilistEpisode != null) {
+      numbered.add(id);
+      byAni.putIfAbsent('$id#${e.anilistEpisode}', () => it);
+    }
     byEp.putIfAbsent('$id#${e.episode}', () => it);
     if (e.absolute != null) byAbs.putIfAbsent('$id#${e.absolute}', () => it);
-    if (e.airDate != null) byDay.putIfAbsent('$id@${_day(e.airDate!)}', () => it);
+    if (e.airDate != null) byDay.putIfAbsent('$id@${_dayKey(_jstDay(e.airDate!))}', () => it);
   }
   return [
     for (final a in airings)
       () {
         final id = a.anilistId;
         final ref = refs[id];
-        final it = byEp['$id#${a.episode}'] ?? byAbs['$id#${a.episode}'] ?? byDay['$id@${_day(a.airingAt)}'];
+        final it = numbered.contains(id)
+            ? byAni['$id#${a.episode}']
+            : byEp['$id#${a.episode}'] ??
+                byAbs['$id#${a.episode}'] ??
+                _airDays(a.airingAt).map((d) => byDay['$id@${_dayKey(d)}']).nonNulls.firstOrNull;
         if (it != null) {
           final e = it.episode;
           return ScheduleEntry(
             airing: a,
             status: ScheduleStatus.of(e.status),
             progress: e.status == EpisodeStatus.downloading ? e.progress : null,
-            reason: e.status == EpisodeStatus.failed ? e.reason : null,
+            reason: e.status == EpisodeStatus.failed || e.status == EpisodeStatus.missing ? e.reason : null,
+            lastSearchedAt: e.lastSearchedAt,
             tracked: true,
-            followed: it.followed || (ref?.followed ?? false),
             seriesId: it.seriesId,
             season: e.season,
+            jellyfinEpisode: e.episode,
             jellyfinSeriesId: it.jellyfinSeriesId ?? ref?.jellyfinSeriesId ?? lib[id]?.$1,
           );
         }
@@ -153,6 +251,7 @@ List<ScheduleEntry> matchSchedule(
             airing: a,
             status: a.airingAt.isAfter(at) ? ScheduleStatus.upcoming : ScheduleStatus.inLibrary,
             season: onJf.$2,
+            jellyfinEpisode: a.episode + onJf.$3,
             jellyfinSeriesId: onJf.$1,
           );
         }
@@ -160,7 +259,6 @@ List<ScheduleEntry> matchSchedule(
           airing: a,
           status: a.airingAt.isAfter(at) ? ScheduleStatus.upcoming : ScheduleStatus.missing,
           tracked: true,
-          followed: ref.followed,
           seriesId: ref.seriesId,
           jellyfinSeriesId: ref.jellyfinSeriesId ?? lib[id]?.$1,
         );
@@ -168,6 +266,46 @@ List<ScheduleEntry> matchSchedule(
   ];
 }
 
+/// The episodes [confirmOnJellyfin] looks up: on Jellyfin, untracked
+/// ([ScheduleStatus.inLibrary]) or available through AnimeFlow.
+bool needsJellyfinLookup(ScheduleEntry e) =>
+    e.jellyfinSeriesId != null && (e.status == ScheduleStatus.inLibrary || e.status == ScheduleStatus.available);
+
+/// Checks [matchSchedule]'s entries against the episodes Jellyfin has:
+/// [episodes] maps a Jellyfin series id to its episodes. An
+/// [ScheduleStatus.inLibrary] one found stays inLibrary, absent becomes
+/// [ScheduleStatus.notOnJellyfin], a series missing from [episodes] (not
+/// looked up) [ScheduleStatus.aired]. Found episodes (inLibrary or
+/// available) get this user's [ScheduleEntry.watch]: (season, episode),
+/// else the one premiered that day.
+List<ScheduleEntry> confirmOnJellyfin(List<ScheduleEntry> entries, Map<String, List<JellyfinEpisodeRef>> episodes) => [
+      for (final e in entries)
+        if (!needsJellyfinLookup(e))
+          e
+        else
+          switch ((episodes[e.jellyfinSeriesId], e.status)) {
+            (null, ScheduleStatus.inLibrary) => e.copyWith(status: ScheduleStatus.aired),
+            (null, _) => e,
+            (final have?, _) => switch (_episodeOf(have, e)) {
+                final x? => e.copyWith(watch: x.watch),
+                null when e.status == ScheduleStatus.inLibrary => e.copyWith(status: ScheduleStatus.notOnJellyfin),
+                null => e,
+              },
+          },
+    ];
+
+JellyfinEpisodeRef? _episodeOf(List<JellyfinEpisodeRef> have, ScheduleEntry e) {
+  final byNumber = have.where((x) => x.season == e.season && x.episode == e.jellyfinEpisode).firstOrNull;
+  if (byNumber != null || !e.tracked) return byNumber;
+  // AnimeFlow's numbering missed (specials, renumbered seasons): the
+  // episode premiered that day, when only one did.
+  return have.where((x) => x.premiere != null && sameAirDay(x.premiere!, e.airing.airingAt)).singleOrNull;
+}
+
+/// The episodes Jellyfin has of a series, as the linked account sees
+/// them; null when it cannot tell (no linked account for that server).
+typedef JellyfinEpisodeLookup = Future<List<JellyfinEpisodeRef>?> Function(String jellyfinSeriesId);
+
 /// One loaded window. Errors are display text; [entries] is empty only
 /// when AniList failed with nothing cached.
 class ScheduleSnapshot {
@@ -203,12 +341,16 @@ class ScheduleSnapshot {
 
 /// Loads AniList and AnimeFlow for a window and merges them.
 class ScheduleRepository {
-  ScheduleRepository({required this.aniList, this.animeFlow, DateTime Function()? now})
+  ScheduleRepository({required this.aniList, this.animeFlow, this.jellyfinEpisodes, DateTime Function()? now})
       : _now = now ?? DateTime.now;
 
   final AniListClient aniList;
   /// Null = not configured (AniList only).
   final AnimeFlowClient? animeFlow;
+  /// Confirms "on Jellyfin" and this user's watched state per episode
+  /// ([confirmOnJellyfin]); null = never confirmed (aired entries read
+  /// [ScheduleStatus.aired], nothing shows as watched).
+  final JellyfinEpisodeLookup? jellyfinEpisodes;
   final DateTime Function() _now;
 
   /// Last week's Monday 00:00 local .. 4 weeks later.
@@ -233,7 +375,8 @@ class ScheduleRepository {
     final flow = await flowF;
     final airings = [...ani.airings]..sort((a, b) => a.airingAt.compareTo(b.airingAt));
     final entries = flow.error == null
-        ? matchSchedule(airings, schedule: flow.schedule, series: flow.series, library: flow.library, now: now)
+        ? await _confirm(
+            matchSchedule(airings, schedule: flow.schedule, series: flow.series, library: flow.library, now: now))
         : [for (final a in airings) untrackedEntry(a, now)];
     return ScheduleSnapshot(
       from: start,
@@ -246,6 +389,27 @@ class ScheduleRepository {
     );
   }
 
+  /// Looks up the episodes of every series an entry on Jellyfin is on
+  /// ([needsJellyfinLookup]), in parallel, one request per series; a
+  /// failed or impossible lookup leaves that series out.
+  Future<List<ScheduleEntry>> _confirm(List<ScheduleEntry> entries) async {
+    final lookup = jellyfinEpisodes;
+    final ids = {
+      for (final e in entries)
+        if (needsJellyfinLookup(e)) e.jellyfinSeriesId!,
+    };
+    final found = <String, List<JellyfinEpisodeRef>>{};
+    if (lookup != null) {
+      await Future.wait([
+        for (final id in ids)
+          lookup(id).then((eps) {
+            if (eps != null) found[id] = eps;
+          }, onError: (_) {}),
+      ]);
+    }
+    return confirmOnJellyfin(entries, found);
+  }
+
   Future<({AnimeFlowMe? me, List<AnimeFlowScheduleItem> schedule, List<AnimeFlowSeries> series, List<AnimeFlowLibraryItem> library, Object? error})>
       _animeFlow(DateTime from, DateTime to, bool force) async {
     final c = animeFlow;

apps/desktop/lib/src/schedule/ui/schedule_actions.dart

@@ -1,7 +1,7 @@
 import 'package:sync_relay_core/core.dart';
 
 import '../../jellyfin/accounts.dart';
-import '../../jellyfin/format.dart' show pickFor;
+import '../../jellyfin/format.dart' show pickFor, progressOf;
 import '../../screens/home/picked_media.dart';
 import '../anilist.dart';
 import '../animeflow.dart';
@@ -47,14 +47,9 @@ String friendlyError(Object e) => switch (e) {
   _ => '$e',
 };
 
-bool _sameDay(DateTime a, DateTime b) {
-  final x = a.toLocal(), y = b.toLocal();
-  return x.year == y.year && x.month == y.month && x.day == y.day;
-}
-
 /// AnimeFlow's episode for [e] (its season and numbering), from the
 /// series detail: same AniList id and episode, else absolute number, else
-/// the same air day. Null when the entry is not tracked or nothing fits.
+/// the same air day ([sameAirDay]). Null when the entry is not tracked or nothing fits.
 Future<AnimeFlowEpisode?> flowEpisodeFor(AnimeFlowClient client, ScheduleEntry e) async {
   final id = e.seriesId;
   if (id == null) return null;
@@ -63,7 +58,7 @@ Future<AnimeFlowEpisode?> flowEpisodeFor(AnimeFlowClient client, ScheduleEntry e
   final mine = eps.where((x) => x.anilistId == null || x.anilistId == a.anilistId).toList();
   return mine.where((x) => x.anilistId == a.anilistId && x.episode == a.episode).firstOrNull ??
       mine.where((x) => x.absolute == a.episode).firstOrNull ??
-      mine.where((x) => x.airDate != null && _sameDay(x.airDate!, a.airingAt)).firstOrNull;
+      mine.where((x) => x.airDate != null && sameAirDay(x.airDate!, a.airingAt)).firstOrNull;
 }
 
 /// The (season, episode) AnimeFlow uses for [e]; falls back to the
@@ -78,7 +73,7 @@ Future<({int season, int episode})> flowNumbering(AnimeFlowClient? client, Sched
     }
   }
   if (ep != null) return (season: ep.season, episode: ep.episode);
-  return (season: e.season ?? 1, episode: e.airing.episode);
+  return (season: e.season ?? 1, episode: e.jellyfinEpisode ?? e.airing.episode);
 }
 
 /// The AniDB id of an untracked AniList entry, from AnimeFlow's search:
@@ -112,6 +107,37 @@ JellyfinAccount? jellyfinAccountFor(JellyfinAccounts accounts, AnimeFlowClient?
   return accounts.defaultAccount;
 }
 
+/// The episodes Jellyfin has of [jellyfinSeriesId] (numbers, premiere
+/// date, this user's watched state), seen by the account AnimeFlow's ids
+/// belong to ([jellyfinAccountFor]): the user's own; null without a
+/// linked account. One request per series, memoised a few minutes
+/// ([JellyfinAccounts.cached]; a stop report drops it,
+/// [JellyfinAccounts.watched]).
+Future<List<JellyfinEpisodeRef>?> jellyfinScheduleEpisodes(
+  JellyfinAccounts accounts,
+  AnimeFlowClient? flow,
+  String jellyfinSeriesId,
+) async {
+  await accounts.ensureLoaded(validate: false);
+  final account = jellyfinAccountFor(accounts, flow);
+  final client = account == null ? null : accounts.clientFor(account.serverId);
+  if (account == null || client == null) return null;
+  return accounts.cached(
+    account.serverId,
+    'schedule-episodes:$jellyfinSeriesId',
+    () async => [
+      for (final x in await client.episodes(jellyfinSeriesId))
+        if (x.parentIndexNumber != null && x.indexNumber != null)
+          JellyfinEpisodeRef(
+            x.parentIndexNumber!,
+            x.indexNumber!,
+            premiere: x.premiereDate,
+            watch: EpisodeWatch(played: x.userData.played, progress: x.userData.played ? 0 : progressOf(x)),
+          ),
+    ],
+  );
+}
+
 /// The Jellyfin episode of an available [e] as a media pick. Throws
 /// [ScheduleActionException] (or a client error) when it cannot be found.
 Future<JellyfinMedia> resolveJellyfinEpisode(JellyfinAccounts accounts, AnimeFlowClient? flow, ScheduleEntry e) async {
@@ -134,7 +160,7 @@ Future<JellyfinMedia> resolveJellyfinEpisode(JellyfinAccounts accounts, AnimeFlo
   final a = e.airing;
   final item =
       eps.where((x) => x.parentIndexNumber == n.season && x.indexNumber == n.episode).firstOrNull ??
-      eps.where((x) => x.premiereDate != null && _sameDay(x.premiereDate!, a.airingAt)).singleOrNull ??
+      eps.where((x) => x.premiereDate != null && sameAirDay(x.premiereDate!, a.airingAt)).singleOrNull ??
       eps.where((x) => x.indexNumber == a.episode).singleOrNull;
   if (item == null) {
     throw ScheduleActionException('Episode ${a.episode} of ${a.title} is not on Jellyfin yet');

apps/desktop/lib/src/schedule/ui/schedule_card.dart

@@ -4,17 +4,17 @@ import 'package:flutter/material.dart';
 import '../schedule_model.dart';
 
 // One day of the Schedule board and its airing cards: cover poster on the
-// left (air time on it, download progress under it), title, episode and
-// status on the right, one full-width action below. Compact mode is a
-// slim row.
+// left (air time on it, download progress or this user's watch progress
+// under it, a check once watched), title, episode and status on the
+// right, one full-width action below. Compact mode is a slim row.
 
 /// What a card's action does, decided by the page.
 enum CardAction {
   none,
   putUp,
 
-  /// Available, but not in a server: shown disabled with a hint.
-  playOffline,
+  /// Available, nobody else watching (offline or solo): plays it here.
+  play,
   request,
   requestSeries,
   requested,
@@ -35,21 +35,55 @@ String countdownText(DateTime at, DateTime now) {
   return 'in ${d.inMinutes}m';
 }
 
+/// Aired, tracked, no release yet: AnimeFlow downloads it by itself.
+bool _waiting(ScheduleEntry e, DateTime now) =>
+    e.status == ScheduleStatus.missing ||
+    (e.status == ScheduleStatus.upcoming && e.tracked && !e.airing.airingAt.isAfter(now));
+
+const waitingHint = 'Aired in Japan; downloads automatically when a release appears';
+
+String _ago(DateTime t, DateTime now) {
+  final m = now.difference(t).inMinutes;
+  return m < 1 ? 'just now' : m < 60 ? '$m min ago' : '${m ~/ 60} h ago';
+}
+
 /// Status line: text, colour, icon.
-(String, Color, IconData) statusBadge(ScheduleEntry e, DateTime now) => switch (e.status) {
-  ScheduleStatus.available => ('on Jellyfin', Colors.greenAccent, Icons.check_circle),
-  ScheduleStatus.downloading => (
-    e.progress == null ? 'downloading' : 'downloading ${(e.progress! * 100).round()}%',
-    Colors.lightBlueAccent,
-    Icons.downloading,
-  ),
-  ScheduleStatus.upcoming => (countdownText(e.airing.airingAt, now), Colors.amber, Icons.schedule),
-  ScheduleStatus.missing => ('missing', Colors.orangeAccent, Icons.report_gmailerrorred),
-  ScheduleStatus.failed => ('failed${e.reason == null ? '' : ' · ${e.reason}'}', Colors.redAccent, Icons.error_outline),
-  ScheduleStatus.unmonitored => ('not monitored', Colors.grey, Icons.visibility_off_outlined),
-  ScheduleStatus.notTracked => ('not in AnimeFlow', Colors.grey, Icons.public),
-  ScheduleStatus.inLibrary => ('on Jellyfin', Colors.greenAccent, Icons.video_library_outlined),
-};
+(String, Color, IconData) statusBadge(ScheduleEntry e, DateTime now) => _waiting(e, now)
+    ? e.reason != null
+        // Releases exist but AnimeFlow rejected them (the hint says why).
+        ? ('release rejected', Colors.orangeAccent, Icons.block)
+        : (
+            e.lastSearchedAt == null ? 'waiting for release' : 'waiting · searched ${_ago(e.lastSearchedAt!, now)}',
+            Colors.amber.shade200,
+            Icons.hourglass_top,
+          )
+    : switch (e.status) {
+        ScheduleStatus.available => ('on Jellyfin', Colors.greenAccent, Icons.check_circle),
+        ScheduleStatus.downloading => (
+          e.progress == null ? 'downloading' : 'downloading ${(e.progress! * 100).round()}%',
+          Colors.lightBlueAccent,
+          Icons.downloading,
+        ),
+        ScheduleStatus.upcoming => (countdownText(e.airing.airingAt, now), Colors.amber, Icons.schedule),
+        ScheduleStatus.missing => ('waiting for release', Colors.amber.shade200, Icons.hourglass_top),
+        ScheduleStatus.failed => (
+          'failed${e.reason == null ? '' : ' · ${e.reason}'}',
+          Colors.redAccent,
+          Icons.error_outline,
+        ),
+        ScheduleStatus.unmonitored => ('not monitored', Colors.grey, Icons.visibility_off_outlined),
+        ScheduleStatus.notTracked => ('not in AnimeFlow', Colors.grey, Icons.public),
+        ScheduleStatus.inLibrary => ('on Jellyfin', Colors.greenAccent, Icons.video_library_outlined),
+        ScheduleStatus.notOnJellyfin => ('aired · not on Jellyfin yet', Colors.grey, Icons.hourglass_empty),
+        ScheduleStatus.aired => ('aired', Colors.grey, Icons.done),
+      };
+
+/// What the status line means, when its text alone does not say.
+String? statusHint(ScheduleEntry e, DateTime now) => !_waiting(e, now)
+    ? null
+    : e.reason != null
+        ? '${e.reason}${e.lastSearchedAt == null ? '' : ' · searched ${_ago(e.lastSearchedAt!, now)}'}'
+        : waitingHint;
 
 class DayColumn extends StatelessWidget {
   final DateTime day;
@@ -125,7 +159,6 @@ class AiringCard extends StatelessWidget {
   final ScheduleEntry entry;
   final DateTime now;
   final bool compact;
-  final bool followed;
   final CardAction action;
 
   /// Why [action] is disabled (no request scope, not on Jellyfin, ...);
@@ -136,20 +169,19 @@ class AiringCard extends StatelessWidget {
   final bool busy;
   final VoidCallback onAction;
 
-  /// Null hides the bookmark (untracked series).
-  final VoidCallback? onFollow;
+  /// Right-click ([context]: the card): the page's menu; null: none.
+  final void Function(BuildContext context)? onMenu;
 
   const AiringCard({
     super.key,
     required this.entry,
     required this.now,
     required this.compact,
-    required this.followed,
     required this.action,
     required this.onAction,
     this.disabledHint,
     this.busy = false,
-    this.onFollow,
+    this.onMenu,
   });
 
   String get _id => '${entry.airing.anilistId}-${entry.airing.episode}';
@@ -157,20 +189,65 @@ class AiringCard extends StatelessWidget {
   Widget _image(String? url, Widget fallback) =>
       url == null ? fallback : Image.network(url, fit: BoxFit.cover, errorBuilder: (_, _, _) => fallback);
 
+  static Widget _hinted(String? hint, Widget child) => hint == null ? child : Tooltip(message: hint, child: child);
+
+  bool get _played => entry.watch?.played ?? false;
+
+  /// A watched episode's cover is a little dimmer.
+  Widget _dimmed(Widget cover) => _played ? Opacity(opacity: 0.6, child: cover) : cover;
+
+  /// This user's state of the episode on Jellyfin: the library cards'
+  /// green check once watched, else a thin bar to the resume point.
+  List<Widget> _watchMarks({bool small = false}) {
+    final w = entry.watch;
+    if (w == null) return const [];
+    if (w.played) {
+      final size = small ? 16.0 : 22.0;
+      return [
+        Positioned(
+          top: small ? 2 : 4,
+          right: small ? 2 : 4,
+          child: Tooltip(
+            message: 'Watched',
+            child: Container(
+              key: ValueKey('watched-$_id'),
+              constraints: BoxConstraints(minWidth: size, minHeight: size),
+              alignment: Alignment.center,
+              decoration: BoxDecoration(color: const Color(0xCC1B5E20), borderRadius: BorderRadius.circular(size / 2)),
+              child: Icon(Icons.check, size: small ? 11 : 14, color: Colors.white),
+            ),
+          ),
+        ),
+      ];
+    }
+    if (w.progress <= 0) return const [];
+    return [
+      Positioned(
+        left: 0,
+        right: 0,
+        bottom: 0,
+        child: Tooltip(
+          message: '${(w.progress * 100).round()}% watched',
+          child: LinearProgressIndicator(
+            key: ValueKey('watch-progress-$_id'),
+            value: w.progress,
+            minHeight: small ? 2 : 3,
+            backgroundColor: Colors.black54,
+          ),
+        ),
+      ),
+    ];
+  }
+
   Widget? _button(BuildContext context) {
     final enabled = disabledHint == null && !busy;
     final spinner = const SizedBox(width: 16, height: 16, child: CircularProgressIndicator(strokeWidth: 2));
     Widget? b = switch (action) {
       CardAction.none => null,
-      CardAction.putUp => FilledButton.tonalIcon(
+      CardAction.putUp || CardAction.play => FilledButton.tonalIcon(
         onPressed: enabled ? onAction : null,
         icon: busy ? spinner : const Icon(Icons.play_arrow, size: 18),
-        label: const Text('Put it up'),
-      ),
-      CardAction.playOffline => FilledButton.tonalIcon(
-        onPressed: null,
-        icon: const Icon(Icons.play_arrow, size: 18),
-        label: const Text('Play'),
+        label: Text(action == CardAction.play ? 'Play' : 'Put it up'),
       ),
       CardAction.request || CardAction.requestSeries => OutlinedButton.icon(
         onPressed: enabled ? onAction : null,
@@ -184,27 +261,12 @@ class AiringCard extends StatelessWidget {
     return disabledHint == null ? b : Tooltip(message: disabledHint!, child: b);
   }
 
-  Widget? _follow(BuildContext context, double size) {
-    final f = onFollow;
-    if (f == null) return null;
-    return IconButton(
-      key: ValueKey('follow-$_id'),
-      onPressed: f,
-      tooltip: followed ? 'Stop following' : 'Follow',
-      visualDensity: VisualDensity.compact,
-      padding: EdgeInsets.zero,
-      constraints: BoxConstraints.tightFor(width: size + 10, height: size + 10),
-      iconSize: size,
-      color: followed ? Theme.of(context).colorScheme.primary : null,
-      icon: Icon(followed ? Icons.bookmark : Icons.bookmark_outline),
-    );
-  }
-
   @override
   Widget build(BuildContext context) {
     final scheme = Theme.of(context).colorScheme;
     final a = entry.airing;
     final (label, color, icon) = statusBadge(entry, now);
+    final hint = statusHint(entry, now);
     final time = clockText(a.airingAt);
     final tintColor = a.color ?? Colors.blueGrey;
     final tint = DecoratedBox(
@@ -216,7 +278,11 @@ class AiringCard extends StatelessWidget {
         ),
       ),
     );
-    final tap = action == CardAction.putUp && disabledHint == null && !busy ? onAction : null;
+    final tap = (action == CardAction.putUp || action == CardAction.play) && disabledHint == null && !busy
+        ? onAction
+        : null;
+    final onMenu = this.onMenu;
+    final menu = onMenu == null || busy ? null : () => onMenu(context);
     if (compact) {
       final requestable = action == CardAction.request || action == CardAction.requestSeries;
       return Material(
@@ -226,13 +292,21 @@ class AiringCard extends StatelessWidget {
         child: InkWell(
           borderRadius: BorderRadius.circular(10),
           onTap: tap,
+          onSecondaryTap: menu,
           child: Padding(
             padding: const EdgeInsets.all(6),
             child: Row(
               children: [
                 ClipRRect(
                   borderRadius: BorderRadius.circular(6),
-                  child: SizedBox(width: 34, height: 48, child: _image(a.cover, tint)),
+                  child: SizedBox(
+                    width: 34,
+                    height: 48,
+                    child: Stack(
+                      fit: StackFit.expand,
+                      children: [_dimmed(_image(a.cover, tint)), ..._watchMarks(small: true)],
+                    ),
+                  ),
                 ),
                 const SizedBox(width: 8),
                 Expanded(
@@ -249,7 +323,6 @@ class AiringCard extends StatelessWidget {
                     ],
                   ),
                 ),
-                if (followed && onFollow == null) Icon(Icons.bookmark, size: 14, color: scheme.primary),
                 if (requestable)
                   Tooltip(
                     message: disabledHint ?? (action == CardAction.request ? 'Request' : 'Request series'),
@@ -263,7 +336,7 @@ class AiringCard extends StatelessWidget {
                   )
                 else
                   Tooltip(
-                    message: label,
+                    message: hint == null ? label : '$label: $hint',
                     child: Icon(icon, size: 16, color: color),
                   ),
               ],
@@ -273,7 +346,6 @@ class AiringCard extends StatelessWidget {
       );
     }
     final button = _button(context);
-    final follow = _follow(context, 16);
     // The cover poster leads: it is what people recognise at a glance.
     return Material(
       key: ValueKey('card-$_id'),
@@ -282,6 +354,7 @@ class AiringCard extends StatelessWidget {
       clipBehavior: Clip.antiAlias,
       child: InkWell(
         onTap: tap,
+        onSecondaryTap: menu,
         child: Padding(
           padding: const EdgeInsets.all(8),
           child: Column(
@@ -298,7 +371,7 @@ class AiringCard extends StatelessWidget {
                       child: Stack(
                         fit: StackFit.expand,
                         children: [
-                          _image(a.cover, tint),
+                          _dimmed(_image(a.cover, tint)),
                           Positioned(
                             left: 4,
                             top: 4,
@@ -314,6 +387,7 @@ class AiringCard extends StatelessWidget {
                               ),
                             ),
                           ),
+                          ..._watchMarks(),
                           if (entry.status == ScheduleStatus.downloading)
                             Positioned(
                               left: 0,
@@ -343,40 +417,29 @@ class AiringCard extends StatelessWidget {
                             style: const TextStyle(fontWeight: FontWeight.w600, height: 1.25),
                           ),
                           const SizedBox(height: 2),
-                          Row(
-                            children: [
-                              Flexible(
-                                child: Text(
-                                  'Episode ${a.episode}',
-                                  maxLines: 1,
-                                  overflow: TextOverflow.ellipsis,
-                                  style: TextStyle(color: scheme.onSurfaceVariant, fontSize: 12),
-                                ),
-                              ),
-                              const SizedBox(width: 2),
-                              if (follow != null)
-                                follow
-                              else if (followed)
-                                Padding(
-                                  padding: const EdgeInsets.only(left: 4),
-                                  child: Icon(Icons.bookmark, size: 14, color: scheme.primary),
-                                ),
-                            ],
+                          Text(
+                            'Episode ${a.episode}',
+                            maxLines: 1,
+                            overflow: TextOverflow.ellipsis,
+                            style: TextStyle(color: scheme.onSurfaceVariant, fontSize: 12),
                           ),
                           const Spacer(),
-                          Row(
-                            children: [
-                              Icon(icon, size: 14, color: color),
-                              const SizedBox(width: 4),
-                              Expanded(
-                                child: Text(
-                                  label,
-                                  maxLines: 2,
-                                  overflow: TextOverflow.ellipsis,
-                                  style: TextStyle(color: color, fontSize: 12),
+                          _hinted(
+                            hint,
+                            Row(
+                              children: [
+                                Icon(icon, size: 14, color: color),
+                                const SizedBox(width: 4),
+                                Expanded(
+                                  child: Text(
+                                    label,
+                                    maxLines: 2,
+                                    overflow: TextOverflow.ellipsis,
+                                    style: TextStyle(color: color, fontSize: 12),
+                                  ),
                                 ),
-                              ),
-                            ],
+                              ],
+                            ),
                           ),
                         ],
                       ),

apps/desktop/lib/src/schedule/ui/schedule_page.dart

@@ -6,6 +6,7 @@ import '../../jellyfin/accounts.dart';
 import '../../screens/home/picked_media.dart';
 import '../../shell/avatar.dart';
 import '../../shell/motion.dart';
+import '../../widgets/app_menu.dart';
 import '../anilist.dart';
 import '../animeflow.dart';
 import '../schedule_model.dart';
@@ -15,17 +16,23 @@ import 'schedule_card.dart';
 
 // The Schedule tab: one column per day from last week's Monday to four
 // weeks out (AniList), each airing with what AnimeFlow has of it, and the
-// one thing to do about it (put it up, request it). Refreshes every
-// minute while visible; ETags keep that cheap.
+// one thing to do about it (put it up, request it; right-click an
+// available one to queue it). Refreshes every minute while visible; ETags
+// keep that cheap. Episodes on Jellyfin show this user's watched state,
+// reloaded after a playback stops (JellyfinAccounts.watched).
 
-enum ScheduleFilter { jellyfin, following, all }
+enum ScheduleFilter { jellyfin, all }
 
 class SchedulePage extends StatefulWidget {
-  /// In a server: available episodes can be put up.
-  final bool online;
+  /// Nobody else watches (offline or solo): available episodes say Play
+  /// (offline that starts a solo session).
+  final bool solo;
 
   /// Puts a Jellyfin episode up in the server; returns an error to show.
   final Future<String?> Function(JellyfinMedia pick) onPutUp;
+
+  /// Adds an episode to Up next; null: no server, the cards have no menu.
+  final AddToQueue? onAddToQueue;
   final void Function(String message) onToast;
 
   /// Null = the page makes (and closes) its own.
@@ -36,8 +43,9 @@ class SchedulePage extends StatefulWidget {
 
   const SchedulePage({
     super.key,
-    required this.online,
+    this.solo = false,
     required this.onPutUp,
+    this.onAddToQueue,
     required this.onToast,
     this.repository,
     this.accounts,
@@ -63,6 +71,7 @@ class _SchedulePageState extends State<SchedulePage> {
   bool _refreshing = false;
   int _gen = 0;
   Timer? _timer;
+  StreamSubscription<String>? _watchedSub;
   final _scroll = ScrollController();
   bool _jumped = false;
 
@@ -74,9 +83,6 @@ class _SchedulePageState extends State<SchedulePage> {
   /// The sheet stays built while it slides out.
   bool _sheetBuilt = false;
 
-  /// Follow toggles not yet confirmed by a reload (series id -> followed).
-  final _followOverride = <int, bool>{};
-
   /// Requested in this run: "anilistId#episode" or "series:anilistId".
   final _requested = <String>{};
 
@@ -96,21 +102,31 @@ class _SchedulePageState extends State<SchedulePage> {
   void initState() {
     super.initState();
     _ownsRepo = widget.repository == null;
-    _repo =
-        widget.repository ??
-        ScheduleRepository(
-          aniList: AniListClient(),
-          animeFlow: AnimeFlowClient.fromAccounts(JellyfinAccounts.instance),
-        );
+    _repo = widget.repository ?? _ownRepo();
     _load();
     _timer = Timer.periodic(SchedulePage.refreshEvery, (_) {
       if (mounted && !_refreshing && TickerMode.valuesOf(context).enabled) _load();
     });
+    // Back from watching: the cards' watched marks follow (the stop report
+    // already dropped the cached episode lists).
+    _watchedSub = _accounts.watched.listen((_) {
+      if (mounted) _load();
+    });
+  }
+
+  ScheduleRepository _ownRepo() {
+    final flow = AnimeFlowClient.fromAccounts(_accounts);
+    return ScheduleRepository(
+      aniList: AniListClient(),
+      animeFlow: flow,
+      jellyfinEpisodes: (id) => jellyfinScheduleEpisodes(_accounts, flow, id),
+    );
   }
 
   @override
   void dispose() {
     _timer?.cancel();
+    _watchedSub?.cancel();
     _scroll.dispose();
     if (_ownsRepo) {
       _repo.aniList.close();
@@ -185,11 +201,8 @@ class _SchedulePageState extends State<SchedulePage> {
     animate ? _scroll.animateTo(x, duration: easeTime, curve: ease) : _scroll.jumpTo(x);
   }
 
-  bool _followed(ScheduleEntry e) => (e.seriesId == null ? null : _followOverride[e.seriesId]) ?? e.followed;
-
   bool _shows(ScheduleEntry e) => switch (_filter) {
     ScheduleFilter.jellyfin => e.tracked || e.onJellyfin,
-    ScheduleFilter.following => _followed(e),
     ScheduleFilter.all => _niche || e.tracked || e.airing.popularity >= SchedulePage.nicheBelow,
   };
 
@@ -215,16 +228,17 @@ class _SchedulePageState extends State<SchedulePage> {
 
   (CardAction, String?) _actionFor(ScheduleEntry e) {
     if (e.status == ScheduleStatus.available || e.status == ScheduleStatus.inLibrary) {
-      if (!widget.online) return (CardAction.playOffline, 'Join or host a server to put it up');
-      if (e.jellyfinSeriesId == null) return (CardAction.putUp, 'Not linked to a Jellyfin series yet');
-      return (CardAction.putUp, null);
+      final put = widget.solo ? CardAction.play : CardAction.putUp;
+      if (e.jellyfinSeriesId == null) return (put, 'Not linked to a Jellyfin series yet');
+      return (put, null);
     }
     final me = _me;
     final CardAction kind;
     if (e.tracked) {
-      kind = e.status == ScheduleStatus.missing || e.status == ScheduleStatus.failed
-          ? CardAction.request
-          : CardAction.none;
+      // Only an unmonitored episode is worth asking for: AnimeFlow grabs
+      // a missing one (no release yet) by itself once a release appears,
+      // and retries a failed one.
+      kind = e.status == ScheduleStatus.unmonitored ? CardAction.request : CardAction.none;
     } else {
       // On Jellyfin already (owner added it by hand): nothing to request.
       kind = me != null && !e.onJellyfin ? CardAction.requestSeries : CardAction.none;
@@ -242,6 +256,7 @@ class _SchedulePageState extends State<SchedulePage> {
   Future<void> _onAction(ScheduleEntry e, CardAction action) async {
     switch (action) {
       case CardAction.putUp:
+      case CardAction.play:
         return _putUp(e);
       case CardAction.request:
       case CardAction.requestSeries:
@@ -266,6 +281,32 @@ class _SchedulePageState extends State<SchedulePage> {
     }
   }
 
+  /// Right-click on an available episode ([context]: its card): Put it
+  /// up, Add to queue, Play next.
+  Future<void> _menu(BuildContext context, ScheduleEntry e) async {
+    final add = widget.onAddToQueue;
+    if (add == null) return;
+    final pick = await showAppMenu<int>(context, items: [
+      AppMenuItem(value: 0, label: widget.solo ? 'Play' : 'Put it up'),
+      const AppMenuItem(value: 1, label: 'Add to queue'),
+      const AppMenuItem(value: 2, label: 'Play next'),
+    ]);
+    if (pick == null || !mounted) return;
+    if (pick == 0) return _putUp(e);
+    final key = 'play:${_key(e)}';
+    if (_busy.contains(key)) return;
+    setState(() => _busy.add(key));
+    try {
+      final media = await resolveJellyfinEpisode(_accounts, _flow, e);
+      final err = await add(media, next: pick == 2);
+      if (err != null) _toast(err);
+    } catch (err) {
+      _toast(friendlyError(err));
+    } finally {
+      if (mounted) setState(() => _busy.remove(key));
+    }
+  }
+
   Future<void> _request(ScheduleEntry e) async {
     final c = _flow;
     if (c == null) return;
@@ -335,21 +376,6 @@ class _SchedulePageState extends State<SchedulePage> {
     },
   );
 
-  Future<void> _toggleFollow(ScheduleEntry e) async {
-    final c = _flow, id = e.seriesId;
-    if (c == null || id == null) return;
-    final next = !_followed(e);
-    setState(() => _followOverride[id] = next);
-    try {
-      await c.setFollowed(id, next);
-      await _load();
-    } catch (err) {
-      _toast(friendlyError(err));
-    } finally {
-      if (mounted) setState(() => _followOverride.remove(id));
-    }
-  }
-
   Future<void> _decide(AnimeFlowRequest r, {required bool approve}) async {
     final c = _flow;
     if (c == null || _reqBusy.contains(r.id)) return;
@@ -387,11 +413,6 @@ class _SchedulePageState extends State<SchedulePage> {
                 icon: Icon(Icons.video_library_outlined),
                 label: Text('On Jellyfin'),
               ),
-              ButtonSegment(
-                value: ScheduleFilter.following,
-                icon: Icon(Icons.bookmark_outline),
-                label: Text('Following'),
-              ),
               ButtonSegment(value: ScheduleFilter.all, icon: Icon(Icons.public), label: Text('All airing')),
             ],
             selected: {_filter},
@@ -530,17 +551,18 @@ class _SchedulePageState extends State<SchedulePage> {
 
   Widget _card(ScheduleEntry e, DateTime now) {
     final (action, hint) = _actionFor(e);
-    final busy = _busy.contains(action == CardAction.putUp ? 'play:${_key(e)}' : _key(e));
+    final busy = _busy.contains(action == CardAction.putUp || action == CardAction.play ? 'play:${_key(e)}' : _key(e));
     return AiringCard(
       entry: e,
       now: now,
       compact: _compact,
-      followed: _followed(e),
       action: action,
       disabledHint: hint,
       busy: busy,
       onAction: () => _onAction(e, action),
-      onFollow: e.tracked && e.seriesId != null && _flow != null ? () => _toggleFollow(e) : null,
+      onMenu: widget.onAddToQueue != null && (action == CardAction.putUp || action == CardAction.play) && hint == null
+          ? (context) => _menu(context, e)
+          : null,
     );
   }
 

apps/desktop/lib/src/screens/home/about_page.dart

@@ -1,44 +1,27 @@
-import 'dart:io';
-
 import 'package:flutter/material.dart';
-import 'package:flutter/services.dart';
+import 'package:signals/signals_flutter.dart';
 
+import '../../platform/app_log.dart';
+import '../../shell/mark_problem.dart';
+import '../../state/session_state.dart';
+import '../../state/settings.dart';
 import '../../update/update_controller.dart';
-import '../../update/updater.dart';
+import '../../widgets/app_menu.dart';
+import '../../widgets/copy_open.dart';
 import 'settings_page.dart';
 import 'ui.dart';
 import 'update_indicator.dart';
 
-/// Opens [url] in the default browser (no url_launcher dependency).
-Future<bool> openInBrowser(String url) async {
-  try {
-    final ProcessResult r;
-    if (Platform.isWindows) {
-      r = await Process.run('rundll32', ['url.dll,FileProtocolHandler', url]);
-    } else if (Platform.isMacOS) {
-      r = await Process.run('open', [url]);
-    } else {
-      r = await Process.run('xdg-open', [url]);
-    }
-    return r.exitCode == 0;
-  } catch (_) {
-    return false;
-  }
-}
+/// The Minimal player skin's credit (README says the same).
+const uoscCredit = 'Player timeline and controls inspired by uosc by tomasklaen, LGPL-2.1 '
+    '(github.com/tomasklaen/uosc).';
 
-/// Name, version, update state and the source link (Settings → About).
+/// Name, version, update state, the source link and the logs (Settings →
+/// About).
 class AboutPanel extends StatelessWidget {
   final UpdateController? updates;
   const AboutPanel({super.key, this.updates});
 
-  Future<void> _open(BuildContext context) async {
-    final messenger = ScaffoldMessenger.maybeOf(context);
-    if (await openInBrowser(repoUrl)) return;
-    await Clipboard.setData(const ClipboardData(text: repoUrl));
-    messenger?.showSnackBar(
-        const SnackBar(content: Text('Could not open a browser — link copied')));
-  }
-
   @override
   Widget build(BuildContext context) {
     final t = Theme.of(context).textTheme;
@@ -49,7 +32,7 @@ class AboutPanel extends StatelessWidget {
             children: [
               Text(appName, style: t.titleLarge),
               const SizedBox(height: 4),
-              SelectableText('Version $appVersion',
+              SelectableText('Version ${displayVersion()}',
                   style: t.bodyMedium?.copyWith(color: Colors.grey)),
               const SizedBox(height: 4),
               UpdateStatusLine(controller: updates),
@@ -58,20 +41,86 @@ class AboutPanel extends StatelessWidget {
                 children: [
                   Expanded(child: SelectableText(repoUrl, style: t.bodySmall)),
                   IconButton(
-                    tooltip: 'Copy link',
+                    tooltip: ReuseText.copyLink,
                     icon: const Icon(Icons.copy, size: 18),
-                    onPressed: () =>
-                        Clipboard.setData(const ClipboardData(text: repoUrl)),
+                    onPressed: () => copyToClipboard(repoUrl, done: 'Link copied'),
                   ),
                   FilledButton.tonalIcon(
-                    onPressed: () => _open(context),
+                    onPressed: () => openLink(repoUrl),
                     icon: const Icon(Icons.open_in_new, size: 18),
                     label: const Text('Source'),
                   ),
                 ],
               ),
+              const SizedBox(height: 4),
+              Text(uoscCredit, key: const ValueKey('uosc-credit'), style: t.bodySmall?.copyWith(color: Colors.grey)),
+              const SizedBox(height: kGap),
+              Text('Something went wrong? Copy diagnostics and send them to whoever helps you: '
+                  'versions and the last hours of the log, passwords, tokens and cookies left out. '
+                  'In a session it can add the server\'s session log, everyone\'s lines merged. '
+                  'Mark a problem (Ctrl+Shift+B) when it happens so the spot is easy to find.',
+                  style: t.bodySmall?.copyWith(color: Colors.grey)),
+              const SizedBox(height: 8),
+              Wrap(
+                spacing: 8,
+                runSpacing: 8,
+                children: [
+                  Builder(
+                    builder: (context) => FilledButton.tonalIcon(
+                      key: const ValueKey('copy-diagnostics'),
+                      onPressed: () => _copyDiagnostics(context),
+                      icon: const Icon(Icons.bug_report_outlined, size: 18),
+                      label: const Text('Copy diagnostics'),
+                    ),
+                  ),
+                  const MarkProblemButton(outlined: true),
+                  OutlinedButton.icon(
+                    onPressed: appLogDir == null ? null : () => _openLogs(),
+                    icon: const Icon(Icons.folder_open, size: 18),
+                    label: const Text('Open logs folder'),
+                  ),
+                ],
+              ),
+              const SizedBox(height: 8),
+              SignalBuilder(
+                builder: (context) => SwitchListTile(
+                  key: const ValueKey('share-diagnostics'),
+                  contentPadding: EdgeInsets.zero,
+                  title: const Text('Share diagnostics with the server'),
+                  subtitle: const Text('In a session, this app\'s log goes to the server\'s session log, '
+                      'merged with everyone\'s, so a problem can be read afterwards. Never chat; '
+                      'passwords and tokens left out. Off: only a problem you mark is sent.'),
+                  value: AppSettings.instance.shareDiagnostics.value,
+                  onChanged: AppSettings.instance.setShareDiagnostics,
+                ),
+              ),
             ],
           ),
         );
   }
+
+  /// In a session it asks whether to add the server's session log.
+  static Future<void> _copyDiagnostics(BuildContext context) async {
+    var withServer = false;
+    if (SessionState.instance.route.peek() == AppRoute.session) {
+      final pick = await showAppMenu<bool>(context, items: const [
+        AppMenuItem(value: false, label: "This app's log"),
+        AppMenuItem(value: true, label: "This app's and the server's session log"),
+      ]);
+      if (pick == null) return;
+      withServer = pick;
+    }
+    final text = await diagnosticsText(sessionLog: withServer);
+    final saved = await saveDiagnostics(text);
+    await copyToClipboard(text,
+        done: saved == null ? 'Diagnostics copied' : 'Diagnostics copied (also saved in the logs folder)');
+  }
+
+  static Future<void> _openLogs() async {
+    final dir = appLogDir;
+    if (dir == null) return;
+    if (!await SessionState.instance.ports.folders.reveal(dir)) {
+      await copyToClipboard(dir, done: "Couldn't open it — folder path copied");
+    }
+  }
 }

apps/desktop/lib/src/screens/home/connect_flow.dart

@@ -1,8 +1,10 @@
 import 'package:flutter/foundation.dart';
 
+import '../../session/connection.dart' show connectErrorText;
+import '../../session/identity.dart';
 import '../../session/session_coordinator.dart';
 import '../../state/session_state.dart';
-import 'profile.dart';
+import '../../sync/sync_client.dart' show HelloRefused;
 
 /// What a card shows under its fields after a failed attempt.
 class CardError {
@@ -23,10 +25,6 @@ class ConnectFlow extends ChangeNotifier {
   int _attempt = 0;
   bool _disposed = false;
 
-  /// Set when an attempt ends in a kick, so the shell shows the removal
-  /// dialog.
-  void Function(String reason)? onKicked;
-
   @override
   void dispose() {
     _disposed = true;
@@ -101,6 +99,7 @@ class ConnectFlow extends ChangeNotifier {
       _notify();
       return;
     }
+    final fromSolo = mode == ConnectMode.host && _session.solo.value;
     try {
       if (mode == ConnectMode.host) {
         await _session.host(params, form);
@@ -110,20 +109,21 @@ class ConnectFlow extends ChangeNotifier {
     } catch (e) {
       if (myAttempt != _attempt) return;
       busy = null;
-      final kick = _session.coordinator.kickReason.peek();
-      if (kick != null && kick.isNotEmpty) {
-        onKicked?.call(kick);
-      } else {
-        errors[mode] = CardError('Could not connect', '$e');
-      }
+      // A refusal says why in plain words (an older host, a wrong password,
+      // another window).
+      errors[mode] = CardError('Could not connect', e is HelloRefused ? connectErrorText(e) : '$e');
       _notify();
       return;
     }
     if (myAttempt != _attempt) {
-      // Cancelled after it got through: back out.
+      // Cancelled after it got through: back out (an Invite: back to solo).
       try {
-        await _session.leave();
-        await _session.stopServer();
+        if (fromSolo) {
+          await _session.cancelInvite();
+        } else {
+          await _session.leave();
+          await _session.stopServer();
+        }
       } catch (_) {}
       return;
     }

apps/desktop/lib/src/screens/home/health_probe.dart

@@ -16,12 +16,15 @@ class ServerHealth {
   final String name;
   final int? proto;
   final int viewers;
+  /// Its Starsync version (`version`), '' from a server too old to say.
+  final String version;
   const ServerHealth.offline()
       : online = false,
         name = '',
         proto = null,
-        viewers = 0;
-  const ServerHealth.online({required this.name, this.proto, this.viewers = 0})
+        viewers = 0,
+        version = '';
+  const ServerHealth.online({required this.name, this.proto, this.viewers = 0, this.version = ''})
       : online = true;
 
   /// True when the server speaks another protocol than this build.
@@ -33,11 +36,12 @@ class ServerHealth {
     try {
       final j = jsonDecode(body);
       if (j is! Map || j['ok'] != true) return const ServerHealth.offline();
-      final name = j['name'], proto = j['proto'], viewers = j['viewers'];
+      final name = j['name'], proto = j['proto'], viewers = j['viewers'], version = j['version'];
       return ServerHealth.online(
         name: name is String ? name.trim() : '',
         proto: proto is num ? proto.toInt() : null,
         viewers: viewers is num ? viewers.toInt() : 0,
+        version: version is String ? version.trim() : '',
       );
     } catch (_) {
       return const ServerHealth.offline();

apps/desktop/lib/src/screens/home/media_picker.dart

@@ -27,7 +27,8 @@ class MediaPickerController extends ChangeNotifier {
   final TextEditingController link;
   final TextEditingController file;
   MediaKind _source;
-  LinkRelay _linkRelay = LinkRelay.direct;
+  // Through me unless picked otherwise (Library → Link).
+  LinkRelay _linkRelay = LinkRelay.me;
   JellyfinMedia? _jellyfin;
   JellyfinSelection? _selected;
 

apps/desktop/lib/src/screens/home/picked_media.dart

@@ -16,7 +16,10 @@ enum LinkRelay { direct, server, me }
 final class LinkMedia extends PickedMedia {
   final String url;
   final LinkRelay relay;
-  const LinkMedia(this.url, {this.relay = LinkRelay.direct});
+  /// Put it up even though this computer's probe found a problem
+  /// (`LinkProbe.problem`): the server or a friend may still open it.
+  final bool anyway;
+  const LinkMedia(this.url, {this.relay = LinkRelay.direct, this.anyway = false});
 
   @override
   String get label {
@@ -119,3 +122,7 @@ final class JellyfinMedia extends PickedMedia {
   @override
   String toString() => 'JellyfinMedia($serverId/$itemId "$title")';
 }
+
+/// Adds a pick to Up next (with [next]: right after what plays); returns
+/// an error text, or null when sent. Null where there is no server.
+typedef AddToQueue = Future<String?> Function(PickedMedia media, {bool next});

apps/desktop/lib/src/screens/home/settings_page.dart

@@ -1,7 +1,7 @@
-import 'package:file_picker/file_picker.dart';
 import 'package:flutter/material.dart';
 import 'package:signals/signals_flutter.dart';
 
+import '../../state/session_state.dart';
 import '../../state/settings.dart';
 import '../../update/update_controller.dart';
 import 'ui.dart';
@@ -12,7 +12,7 @@ import 'update_indicator.dart';
 const sessionShortcuts = [
   ('Space', 'Toggle ready'),
   ('← / →', 'Seek back / forward 10 s'),
-  ('↑ / ↓', 'Volume up / down (up to 150 %)'),
+  ('↑ / ↓, wheel', 'Volume up / down (up to 150 %)'),
   ('Shift+→', 'Skip 1:30 (for everyone)'),
   ('PgUp / PgDn', 'Previous / next chapter'),
   ('F', 'Toggle fullscreen'),
@@ -22,7 +22,8 @@ const sessionShortcuts = [
   ('< or Shift+P', 'Put up the previous Jellyfin episode'),
   ('Ctrl+1…6', 'Shaders: Anime4K mode A, B, C, A+A, B+B, C+A'),
   ('Ctrl+0', 'Shaders off'),
-  ('Esc', 'Close the panel or fullscreen, else ask to leave'),
+  ('Esc', 'Close the panel or fullscreen, shrink the player, then ask to leave'),
+  ('Ctrl+Shift+B', 'Mark a problem in the session log (anywhere)'),
 ];
 
 /// One titled card of the Settings tab (rounded Material, so list tiles
@@ -88,12 +89,11 @@ class CustomShaderFiles extends StatelessWidget {
   const CustomShaderFiles({super.key});
 
   Future<void> _addFiles() async {
-    final List<PlatformFile> files;
+    final List<String> files;
     try {
-      files = await FilePicker.pickFiles(
+      files = await SessionState.instance.ports.folders.pickFiles(
         dialogTitle: 'Pick mpv GLSL shaders',
-        type: FileType.custom,
-        allowedExtensions: const ['glsl', 'hook'],
+        extensions: const ['glsl', 'hook'],
       );
     } catch (_) {
       return;
@@ -101,8 +101,8 @@ class CustomShaderFiles extends StatelessWidget {
     final s = AppSettings.instance;
     final current = s.customShaders.peek();
     final added = [
-      for (final f in files)
-        if (f.path case final p? when !current.contains(p)) p,
+      for (final p in files)
+        if (!current.contains(p)) p,
     ];
     if (added.isNotEmpty) s.setCustomShaders([...current, ...added]);
   }
@@ -197,8 +197,8 @@ class UpdateSettings extends StatelessWidget {
           builder: (context) => SwitchListTile(
             key: const ValueKey('auto-check-updates'),
             contentPadding: EdgeInsets.zero,
-            title: const Text('Check for updates on start'),
-            subtitle: const Text('Looks for a new version when the app opens; nothing installs without asking'),
+            title: const Text('Check for updates automatically'),
+            subtitle: const Text('When the app opens and every few hours; nothing installs without asking'),
             value: s.autoCheckUpdates.value,
             onChanged: s.setAutoCheckUpdates,
           ),

apps/desktop/lib/src/screens/home/ui.dart

@@ -1,10 +1,31 @@
 import 'package:flutter/material.dart';
+import 'package:sync_relay_core/core.dart' show appVersion, isDevBuild;
 
 /// Product name (working title). Change it here only.
-const appName = 'Watch Together';
+const appName = 'Starsync';
 
 const repoUrl = 'https://git.senkochan.moe/Foxyz/sync_replay_project';
 
+/// The pubspec's version: the Flutter tool defines it for every build and
+/// run (`flutter run` too).
+const _pubspecVersion = String.fromEnvironment('FLUTTER_BUILD_NAME');
+
+/// The short commit a packaged build was made from (`tool/package_linux.sh`;
+/// `-dirty` with uncommitted changes); empty otherwise.
+const _gitCommit = String.fromEnvironment('GIT_COMMIT');
+
+/// The version to show: a release's own ("1.1.2"), a test build's with its
+/// commit ("1.1.3-dev.12 · 1a2b3c4"), and for a dev run (no `APP_VERSION`)
+/// the pubspec's with "dev" ("1.1.2 · dev run").
+String displayVersion({String version = appVersion, String pubspec = _pubspecVersion, String commit = _gitCommit}) {
+  if (version == '0.0.0-dev') return pubspec.isEmpty ? 'dev run' : '$pubspec · dev run';
+  return isDevBuild(version) && commit.isNotEmpty ? '$version · $commit' : version;
+}
+
+/// The version in a few characters, always on screen (under the strip's
+/// Settings tab): "1.2.1", "1.2.1-dev.2", "dev run".
+String shortVersion({String version = appVersion}) => version == '0.0.0-dev' ? 'dev run' : version;
+
 const kRadius = 12.0;
 const kGap = 16.0;
 

apps/desktop/lib/src/screens/home/update_indicator.dart

@@ -1,14 +1,17 @@
 import 'package:flutter/material.dart';
+import 'package:sync_relay_core/core.dart' show isDevBuild;
 
 import '../../update/update_controller.dart';
 import '../../widgets/update_banner.dart';
 import 'ui.dart';
 
-/// Compact "Update vX" pill for the party strip; hidden until there is
-/// something to install. Click opens the full [UpdateBanner].
-class UpdateIndicator extends StatelessWidget {
+/// The band across the top of the window while an update is up for
+/// grabs: "Starsync 1.2.1 is ready", its notes, Update and restart and
+/// Later (gone until the next check or start). The shell keeps it off
+/// the full player while a video is on ([AppShell]).
+class UpdateBar extends StatelessWidget {
   final UpdateController? controller;
-  const UpdateIndicator({super.key, this.controller});
+  const UpdateBar({super.key, this.controller});
 
   @override
   Widget build(BuildContext context) {
@@ -21,34 +24,102 @@ class UpdateIndicator extends StatelessWidget {
           return const SizedBox.shrink();
         }
         final scheme = Theme.of(context).colorScheme;
+        final alert = m.isRequired || s.phase == UpdatePhase.failed;
+        final fg = alert ? scheme.onErrorContainer : scheme.onPrimaryContainer;
+        final current = c.currentVersion;
+        // A release (not a test build) that is behind: say which it runs.
+        final behind = isDevBuild(current) ? null : 'You are running $current';
+        final String title;
+        String detail;
+        switch (s.phase) {
+          case UpdatePhase.downloading:
+            title = 'Downloading $appName ${m.version}… ${((s.progress ?? 0) * 100).round()}%';
+            detail = '';
+          case UpdatePhase.applying:
+            title = 'Installing $appName ${m.version}…';
+            detail = '';
+          case UpdatePhase.restarting:
+            title = 'Restarting into $appName ${m.version}…';
+            detail = '';
+          case UpdatePhase.failed:
+            title = 'Update to $appName ${m.version} failed';
+            detail = '${s.error}';
+          case UpdatePhase.available || UpdatePhase.idle:
+            if (!s.canInstall) {
+              title = 'This copy of $appName is older than the latest release (${m.version})';
+              detail = 'Download the new release and replace this folder by hand';
+            } else if (m.isRequired) {
+              title = '$appName ${m.version} is required to join servers on it';
+              detail = m.notes;
+            } else {
+              title = '$appName ${m.version} is ready';
+              detail = m.notes;
+            }
+            detail = [?behind, detail].where((t) => t.isNotEmpty).join(' · ');
+        }
         final busy = s.phase == UpdatePhase.downloading ||
             s.phase == UpdatePhase.applying ||
             s.phase == UpdatePhase.restarting;
-        final label = switch (s.phase) {
-          UpdatePhase.downloading =>
-            'Updating ${((s.progress ?? 0) * 100).round()}%',
-          UpdatePhase.applying => 'Installing…',
-          UpdatePhase.restarting => 'Restarting…',
-          UpdatePhase.failed => 'Update failed',
-          _ => m.isRequired ? 'Required update' : 'Update v${m.version}',
-        };
-        return Tooltip(
-          message: 'Show update',
-          child: FilledButton.tonalIcon(
-            style: FilledButton.styleFrom(
-              backgroundColor: m.isRequired || s.phase == UpdatePhase.failed
-                  ? scheme.errorContainer
-                  : null,
-              visualDensity: VisualDensity.compact,
+        return Material(
+          key: const ValueKey('update-bar'),
+          color: alert ? scheme.errorContainer : scheme.primaryContainer,
+          child: Padding(
+            padding: const EdgeInsets.fromLTRB(16, 8, 12, 8),
+            child: Row(
+              children: [
+                if (busy)
+                  SizedBox.square(
+                    dimension: 18,
+                    child: CircularProgressIndicator(
+                      strokeWidth: 2,
+                      color: fg,
+                      value: s.phase == UpdatePhase.downloading ? s.progress : null,
+                    ),
+                  )
+                else
+                  Icon(Icons.system_update_alt, size: 20, color: fg),
+                const SizedBox(width: 12),
+                Expanded(
+                  child: Column(
+                    crossAxisAlignment: CrossAxisAlignment.start,
+                    mainAxisSize: MainAxisSize.min,
+                    children: [
+                      Text(title,
+                          maxLines: 1,
+                          overflow: TextOverflow.ellipsis,
+                          style: TextStyle(color: fg, fontWeight: FontWeight.w600)),
+                      if (detail.isNotEmpty)
+                        Tooltip(
+                          message: detail,
+                          waitDuration: const Duration(milliseconds: 600),
+                          child: Text(detail,
+                              maxLines: 1,
+                              overflow: TextOverflow.ellipsis,
+                              style: TextStyle(color: fg.withValues(alpha: 0.8), fontSize: 12)),
+                        ),
+                    ],
+                  ),
+                ),
+                if (!busy) ...[
+                  const SizedBox(width: 12),
+                  if (!m.isRequired)
+                    TextButton(
+                      key: const ValueKey('update-later'),
+                      style: TextButton.styleFrom(foregroundColor: fg),
+                      onPressed: c.dismiss,
+                      child: const Text('Later'),
+                    ),
+                  if (s.canInstall) ...[
+                    const SizedBox(width: 4),
+                    FilledButton(
+                      key: const ValueKey('update-install'),
+                      onPressed: c.install,
+                      child: Text(s.phase == UpdatePhase.failed ? 'Retry' : 'Update and restart'),
+                    ),
+                  ],
+                ],
+              ],
             ),
-            onPressed: () => showUpdateDialog(context, controller: c),
-            icon: busy
-                ? const SizedBox(
-                    width: 14,
-                    height: 14,
-                    child: CircularProgressIndicator(strokeWidth: 2))
-                : const Icon(Icons.system_update_alt, size: 18),
-            label: Text(label),
           ),
         );
       },
@@ -85,6 +156,9 @@ Future<void> showUpdateDialog(BuildContext context, {UpdateController? controlle
   );
 }
 
+/// How often a running app looks again (auto-check on).
+const updateCheckEvery = Duration(hours: 4);
+
 enum UpdateCheck { notRun, checking, done }
 
 /// Progress of this run's update check, for Settings/About wording.

apps/desktop/lib/src/screens/session/jellyfin_widgets.dart

@@ -2,43 +2,14 @@ import 'package:flutter/material.dart';
 
 import '../../jellyfin/session_media.dart';
 import '../../session/session_coordinator.dart' show AutoAdvance, autoAdvanceSecs;
+import '../../widgets/app_menu.dart' show AppGlass;
 import 'player_controls.dart' show FloatingPill;
 
 // Jellyfin pieces of the session player. Plain widgets fed by the
 // coordinator's signals, so tests can pump them without the player.
 
-/// Previous / next episode in the video controls. Nothing when there is
-/// no such episode or this viewer cannot put it up (no account).
-class EpisodeSkipButton extends StatelessWidget {
-  final EpisodeLink? episode;
-  final bool next;
-  final VoidCallback onPressed;
-  final FocusNode? focusNode;
-  const EpisodeSkipButton(
-      {super.key, required this.episode, required this.next, required this.onPressed, this.focusNode});
-
-  @override
-  Widget build(BuildContext context) {
-    final e = episode;
-    if (e == null) return const SizedBox.shrink();
-    return Tooltip(
-      message: '${next ? 'Next' : 'Previous'}: ${e.label}  (${next ? '> or Shift+N' : '< or Shift+P'})',
-      child: IconButton(
-        key: ValueKey(next ? 'episode-next' : 'episode-previous'),
-        focusNode: focusNode,
-        color: Colors.white,
-        iconSize: 22,
-        visualDensity: VisualDensity.compact,
-        icon: Icon(next ? Icons.skip_next_rounded : Icons.skip_previous_rounded),
-        onPressed: onPressed,
-      ),
-    );
-  }
-}
-
-/// Floating "Next episode ›" from the ED (or the last two minutes):
-/// faint at rest, lit on hover. Lives outside the auto-hiding controls, so
-/// it shows in fullscreen and with the controls hidden.
+/// Floating "Next episode ›" from the ED (or the last two minutes), while
+/// the controls are up (`PillGate`): faint at rest, lit on hover.
 class NextEpisodePill extends StatelessWidget {
   final EpisodeLink episode;
   final VoidCallback onPressed;
@@ -70,27 +41,36 @@ class EndOfEpisodeCard extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    final t = Theme.of(context).textTheme;
     final c = countdown;
-    return Card(
+    // The same card as Up next's (`UpNextCard`): the app's glass, 400 wide.
+    return AppGlass(
       key: const ValueKey('end-of-episode'),
-      color: Colors.black.withValues(alpha: 0.85),
-      child: Padding(
-        padding: const EdgeInsets.fromLTRB(16, 12, 12, 12),
-        child: ConstrainedBox(
-          constraints: const BoxConstraints(maxWidth: 380),
+      child: SizedBox(
+        width: 400,
+        child: Padding(
+          padding: const EdgeInsets.all(12),
           child: Column(
             mainAxisSize: MainAxisSize.min,
-            crossAxisAlignment: CrossAxisAlignment.start,
+            crossAxisAlignment: CrossAxisAlignment.stretch,
             children: [
               Text(c == null ? 'Up next' : 'Next episode in ${c.secondsLeft} s',
-                  style: t.labelLarge?.copyWith(color: Colors.white70)),
-              const SizedBox(height: 4),
+                  style: const TextStyle(color: Colors.white60, fontSize: 12)),
+              const SizedBox(height: 2),
               Text('Next: ${next.label}',
-                  maxLines: 2, overflow: TextOverflow.ellipsis, style: t.titleMedium),
+                  maxLines: 2,
+                  overflow: TextOverflow.ellipsis,
+                  style: const TextStyle(color: Colors.white, fontSize: 15, fontWeight: FontWeight.w600, height: 1.25)),
               if (c != null) ...[
-                const SizedBox(height: 8),
-                LinearProgressIndicator(value: c.secondsLeft / autoAdvanceSecs),
+                const SizedBox(height: 10),
+                ClipRRect(
+                  borderRadius: BorderRadius.circular(2),
+                  child: TweenAnimationBuilder<double>(
+                    tween: Tween(end: c.secondsLeft / autoAdvanceSecs),
+                    duration: const Duration(seconds: 1),
+                    builder: (context, v, _) =>
+                        LinearProgressIndicator(value: v, minHeight: 3, backgroundColor: const Color(0x1FFFFFFF)),
+                  ),
+                ),
               ],
               const SizedBox(height: 10),
               Row(
@@ -166,25 +146,3 @@ class JellyfinBlockedCard extends StatelessWidget {
     );
   }
 }
-
-/// Small member-list badge: plays the Jellyfin item through the host.
-class ViaHostBadge extends StatelessWidget {
-  const ViaHostBadge({super.key});
-
-  @override
-  Widget build(BuildContext context) {
-    return Tooltip(
-      message: 'No Jellyfin account here: watches through the host',
-      child: Container(
-        key: const ValueKey('via-host'),
-        padding: const EdgeInsets.symmetric(horizontal: 6, vertical: 1),
-        decoration: BoxDecoration(
-          color: Colors.white10,
-          borderRadius: BorderRadius.circular(999),
-          border: Border.all(color: Colors.white24),
-        ),
-        child: const Text('via host', style: TextStyle(fontSize: 10, color: Colors.white70)),
-      ),
-    );
-  }
-}

apps/desktop/lib/src/screens/session/player_controls.dart

@@ -1,534 +1,19 @@
-import 'dart:async';
-import 'dart:math' as math;
-
 import 'package:flutter/material.dart';
-import 'package:media_kit/media_kit.dart';
-import 'package:sync_relay_core/core.dart' show JellyfinStreamType;
 
-import '../../jellyfin/track_prefs.dart' show MpvTrack;
 import '../../playback/media_marks.dart';
+import '../../widgets/app_menu.dart' show AppGlass;
 
-// Session control-bar pieces built on the playback signals (chapters,
-// tracks, skip offers): the seek bar with chapter marks, the chapter and
-// track menus, the 1:30 skip button and the floating skip pill. Plain
-// widgets fed by values and callbacks, so tests pump them without a player.
+// The player's floating action pills (Skip OP / ED / 1:30, Next episode):
+// plain widgets fed by values and callbacks, so tests pump them without a
+// player. They live in the action area, outside the controls.
 
-/// Keeps media_kit's desktop controls shown, as a mouse hover would.
-/// While a seek bar drag runs no hover events arrive, and the controls
-/// would hide (and unmount the bar) mid-drag. A guarded dynamic call on
-/// the private controls state; nothing happens outside those controls.
-void keepVideoControlsAwake(BuildContext context) {
-  context.visitAncestorElements((e) {
-    if (e is StatefulElement &&
-        e.state.runtimeType.toString() == '_MaterialDesktopVideoControlsState') {
-      try {
-        (e.state as dynamic).onHover();
-      } catch (_) {}
-      return false;
-    }
-    return true;
-  });
-}
-
-/// The seek bar: played / buffered track, a diamond at each chapter start
-/// (not the one at 0), and on hover the time with the chapter title above
-/// it. Like media_kit's bar it reports a seek on every drag move and on
-/// release ([onSeek]); the session routes those through the user-seek path
-/// (debounced, everyone follows).
-class ChapterSeekBar extends StatefulWidget {
-  final Duration position;
-  final Duration duration;
-  final Duration buffer;
-  final List<MediaChapter> chapters;
-  final ValueChanged<Duration> onSeek;
-  /// Any pointer activity on the bar (keeps the controls up).
-  final VoidCallback? onActivity;
-  const ChapterSeekBar({
-    super.key,
-    required this.position,
-    required this.duration,
-    this.buffer = Duration.zero,
-    this.chapters = const [],
-    required this.onSeek,
-    this.onActivity,
-  });
-
-  static const height = 28.0;
-
-  @override
-  State<ChapterSeekBar> createState() => _ChapterSeekBarState();
-}
-
-class _ChapterSeekBarState extends State<ChapterSeekBar> {
-  double? _hoverX;
-  bool _dragging = false;
-  double _dragFraction = 0;
-
-  double _fraction(Duration d) {
-    final total = widget.duration.inMicroseconds;
-    if (total <= 0) return 0;
-    return (d.inMicroseconds / total).clamp(0.0, 1.0);
-  }
-
-  Duration _at(double fraction) => widget.duration * fraction.clamp(0.0, 1.0);
-
-  void _seekTo(double x, double width) {
-    if (widget.duration <= Duration.zero || width <= 0) return;
-    _dragFraction = (x / width).clamp(0.0, 1.0);
-    widget.onSeek(_at(_dragFraction));
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    final primary = Theme.of(context).colorScheme.primary;
-    return LayoutBuilder(builder: (context, constraints) {
-      final width = constraints.maxWidth;
-      final active = _hoverX != null || _dragging;
-      final barHeight = active ? 5.0 : 3.0;
-      final played = _dragging ? _dragFraction : _fraction(widget.position);
-      const mid = ChapterSeekBar.height / 2;
-      final hoverX = _hoverX;
-      final hoverAt = hoverX == null || width <= 0 ? null : _at(hoverX / width);
-      final hoverChapter = hoverAt == null ? null : chapterIndexAt(widget.chapters, hoverAt);
-      final hoverTitle = hoverChapter == null ? '' : widget.chapters[hoverChapter].title;
-      return MouseRegion(
-        cursor: SystemMouseCursors.click,
-        onEnter: (e) => setState(() => _hoverX = e.localPosition.dx.clamp(0, width)),
-        onHover: (e) {
-          setState(() => _hoverX = e.localPosition.dx.clamp(0, width));
-          widget.onActivity?.call();
-        },
-        onExit: (_) => setState(() => _hoverX = null),
-        child: Listener(
-          behavior: HitTestBehavior.opaque,
-          onPointerDown: (e) {
-            widget.onActivity?.call();
-            setState(() {
-              _dragging = true;
-              _dragFraction = width <= 0 ? 0 : (e.localPosition.dx / width).clamp(0.0, 1.0);
-            });
-          },
-          onPointerMove: (e) {
-            widget.onActivity?.call();
-            setState(() => _hoverX = e.localPosition.dx.clamp(0, width));
-            _seekTo(e.localPosition.dx, width);
-          },
-          onPointerUp: (e) {
-            _seekTo(e.localPosition.dx, width);
-            setState(() => _dragging = false);
-            widget.onActivity?.call();
-          },
-          onPointerCancel: (_) => setState(() => _dragging = false),
-          child: SizedBox(
-            key: const ValueKey('seek-bar'),
-            width: width,
-            height: ChapterSeekBar.height,
-            child: Stack(
-              clipBehavior: Clip.none,
-              children: [
-                Positioned(
-                  left: 0,
-                  right: 0,
-                  top: mid - barHeight / 2,
-                  height: barHeight,
-                  child: Container(color: Colors.white24),
-                ),
-                Positioned(
-                  left: 0,
-                  top: mid - barHeight / 2,
-                  height: barHeight,
-                  width: width * _fraction(widget.buffer),
-                  child: Container(color: Colors.white24),
-                ),
-                if (hoverX != null && !_dragging)
-                  Positioned(
-                    left: 0,
-                    top: mid - barHeight / 2,
-                    height: barHeight,
-                    width: hoverX,
-                    child: Container(color: Colors.white24),
-                  ),
-                Positioned(
-                  left: 0,
-                  top: mid - barHeight / 2,
-                  height: barHeight,
-                  width: width * played,
-                  child: Container(color: primary),
-                ),
-                for (final c in widget.chapters)
-                  if (c.start > Duration.zero && widget.duration > Duration.zero)
-                    Positioned(
-                      key: ValueKey('chapter-mark-${c.index}'),
-                      left: width * _fraction(c.start) - 4,
-                      top: mid - 4,
-                      width: 8,
-                      height: 8,
-                      child: IgnorePointer(
-                        child: Transform.rotate(
-                          angle: math.pi / 4,
-                          child: Container(
-                            margin: const EdgeInsets.all(1),
-                            decoration: BoxDecoration(
-                              color: Colors.white,
-                              border: Border.all(color: Colors.black54, width: 0.8),
-                            ),
-                          ),
-                        ),
-                      ),
-                    ),
-                if (active)
-                  Positioned(
-                    left: width * played - 6,
-                    top: mid - 6,
-                    width: 12,
-                    height: 12,
-                    child: IgnorePointer(
-                      child: DecoratedBox(
-                        decoration: BoxDecoration(color: primary, shape: BoxShape.circle),
-                      ),
-                    ),
-                  ),
-                if (hoverAt != null)
-                  Positioned(
-                    // Kept clear of the window edges (the tip is centred).
-                    left: hoverX!.clamp(math.min(60.0, width / 2), math.max(width - 60, width / 2)),
-                    bottom: ChapterSeekBar.height - 2,
-                    child: IgnorePointer(
-                      child: FractionalTranslation(
-                        translation: const Offset(-0.5, 0),
-                        child: _HoverTip(title: hoverTitle, time: formatClock(hoverAt)),
-                      ),
-                    ),
-                  ),
-              ],
-            ),
-          ),
-        ),
-      );
-    });
-  }
-}
-
-class _HoverTip extends StatelessWidget {
-  final String title;
-  final String time;
-  const _HoverTip({required this.title, required this.time});
-
-  @override
-  Widget build(BuildContext context) {
-    return Container(
-      constraints: const BoxConstraints(maxWidth: 320),
-      padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
-      decoration: BoxDecoration(
-        color: Colors.black.withValues(alpha: 0.8),
-        borderRadius: BorderRadius.circular(6),
-      ),
-      child: Column(
-        mainAxisSize: MainAxisSize.min,
-        children: [
-          if (title.isNotEmpty)
-            Text(title,
-                key: const ValueKey('seek-hover-chapter'),
-                maxLines: 1,
-                overflow: TextOverflow.ellipsis,
-                style: const TextStyle(color: Colors.white, fontSize: 12, fontWeight: FontWeight.w600)),
-          Text(time,
-              key: const ValueKey('seek-hover-time'),
-              style: const TextStyle(color: Colors.white70, fontSize: 11)),
-        ],
-      ),
-    );
-  }
-}
-
-/// [ChapterSeekBar] on a live player: position, duration and buffer from
-/// its streams. Seeks go to `player.seek`, which the session's
-/// `SyncPlayer` turns into user seeks.
-class PlayerSeekBar extends StatefulWidget {
-  final Player player;
-  final List<MediaChapter> chapters;
-  const PlayerSeekBar({super.key, required this.player, required this.chapters});
-
-  @override
-  State<PlayerSeekBar> createState() => _PlayerSeekBarState();
-}
-
-class _PlayerSeekBarState extends State<PlayerSeekBar> {
-  final List<StreamSubscription<Object>> _subs = [];
-  late Duration _position, _duration, _buffer;
-
-  @override
-  void initState() {
-    super.initState();
-    _listen();
-  }
-
-  @override
-  void didUpdateWidget(PlayerSeekBar old) {
-    super.didUpdateWidget(old);
-    if (!identical(old.player, widget.player)) {
-      _cancel();
-      _listen();
-    }
-  }
-
-  void _listen() {
-    final p = widget.player;
-    _position = p.state.position;
-    _duration = p.state.duration;
-    _buffer = p.state.buffer;
-    void set(VoidCallback f) {
-      if (mounted) setState(f);
-    }
-
-    _subs.addAll([
-      p.stream.position.listen((d) => set(() => _position = d)),
-      p.stream.duration.listen((d) => set(() => _duration = d)),
-      p.stream.buffer.listen((d) => set(() => _buffer = d)),
-    ]);
-  }
-
-  void _cancel() {
-    for (final s in _subs) {
-      s.cancel();
-    }
-    _subs.clear();
-  }
-
-  @override
-  void dispose() {
-    _cancel();
-    super.dispose();
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    return ChapterSeekBar(
-      position: _position,
-      duration: _duration,
-      buffer: _buffer,
-      chapters: widget.chapters,
-      onSeek: (d) => widget.player.seek(d),
-      onActivity: () => keepVideoControlsAwake(context),
-    );
-  }
-}
-
-RelativeRect _menuPosition(BuildContext context) {
-  final button = context.findRenderObject() as RenderBox;
-  final overlay = Navigator.of(context).overlay!.context.findRenderObject() as RenderBox;
-  return RelativeRect.fromRect(
-    Rect.fromPoints(
-      button.localToGlobal(Offset.zero, ancestor: overlay),
-      button.localToGlobal(button.size.bottomRight(Offset.zero), ancestor: overlay),
-    ),
-    Offset.zero & overlay.size,
-  );
-}
-
-/// Control-bar icon with a small count in the corner.
-class _BadgedIcon extends StatelessWidget {
-  final IconData icon;
-  final int count;
-  const _BadgedIcon(this.icon, this.count);
-
-  @override
-  Widget build(BuildContext context) {
-    return Stack(
-      clipBehavior: Clip.none,
-      children: [
-        Icon(icon),
-        if (count > 0)
-          Positioned(
-            right: -7,
-            top: -5,
-            child: Container(
-              padding: const EdgeInsets.symmetric(horizontal: 4, vertical: 0.5),
-              decoration: BoxDecoration(
-                color: Theme.of(context).colorScheme.primary,
-                borderRadius: BorderRadius.circular(999),
-              ),
-              child: Text('$count',
-                  style: const TextStyle(color: Colors.white, fontSize: 9, fontWeight: FontWeight.bold)),
-            ),
-          ),
-      ],
-    );
-  }
-}
-
-/// Chapter list for the controls: current chapter checked, a pick seeks
-/// to its start. Nothing when the file has no chapters.
-class ChaptersControlButton extends StatelessWidget {
-  final List<MediaChapter> chapters;
-  final int? current;
-  final ValueChanged<MediaChapter> onPick;
-  final FocusNode? focusNode;
-  final ValueChanged<bool>? onMenuOpen;
-  const ChaptersControlButton({
-    super.key,
-    required this.chapters,
-    required this.current,
-    required this.onPick,
-    this.focusNode,
-    this.onMenuOpen,
-  });
-
-  @override
-  Widget build(BuildContext context) {
-    if (chapters.isEmpty) return const SizedBox.shrink();
-    return Tooltip(
-      message: 'Chapters (PgUp / PgDn)',
-      child: IconButton(
-        key: const ValueKey('chapters-button'),
-        focusNode: focusNode,
-        color: Colors.white,
-        iconSize: 20,
-        visualDensity: VisualDensity.compact,
-        icon: _BadgedIcon(Icons.format_list_bulleted, chapters.length),
-        onPressed: () => _open(context),
-      ),
-    );
-  }
-
-  Future<void> _open(BuildContext context) async {
-    final position = _menuPosition(context);
-    onMenuOpen?.call(true);
-    final pick = await showMenu<MediaChapter>(
-      context: context,
-      position: position,
-      popUpAnimationStyle: AnimationStyle.noAnimation,
-      constraints: const BoxConstraints(minWidth: 240, maxWidth: 420),
-      items: [
-        for (final c in chapters)
-          CheckedPopupMenuItem(
-            value: c,
-            checked: c.index == current,
-            height: 36,
-            child: Row(
-              children: [
-                Expanded(
-                  child: Text(c.title.isEmpty ? 'Chapter ${c.index + 1}' : c.title,
-                      maxLines: 1, overflow: TextOverflow.ellipsis),
-                ),
-                const SizedBox(width: 12),
-                Text(formatClock(c.start), style: const TextStyle(fontSize: 12, color: Colors.grey)),
-              ],
-            ),
-          ),
-      ],
-    );
-    onMenuOpen?.call(false);
-    if (pick != null) onPick(pick);
-  }
-}
-
-/// A track pick from [TrackMenuButton]: audio id, subtitle id, or off.
-typedef TrackPick = ({int? aid, int? sid, bool subtitlesOff});
-
-/// Audio or subtitle menu for the controls bar (the count of tracks on the
-/// icon): "Japanese · E-AC3 2.0 · title", mpv's selection checked,
-/// subtitles with Off. The choice is remembered for the next Jellyfin item
-/// (per viewer).
-class TrackMenuButton extends StatelessWidget {
-  final JellyfinStreamType type;
-  /// All tracks; only those of [type] are listed.
-  final List<MpvTrack> tracks;
-  final void Function(TrackPick pick) onPick;
-  final FocusNode? focusNode;
-  final ValueChanged<bool>? onMenuOpen;
-  const TrackMenuButton({
-    super.key,
-    required this.type,
-    required this.tracks,
-    required this.onPick,
-    this.focusNode,
-    this.onMenuOpen,
-  });
-
-  bool get _audio => type == JellyfinStreamType.audio;
-
-  @override
-  Widget build(BuildContext context) {
-    final list = tracks.where((t) => t.type == type).toList();
-    return Tooltip(
-      message: _audio ? 'Audio' : 'Subtitles',
-      child: IconButton(
-        key: ValueKey(_audio ? 'audio-button' : 'subtitles-button'),
-        focusNode: focusNode,
-        color: Colors.white,
-        iconSize: 20,
-        visualDensity: VisualDensity.compact,
-        icon: _BadgedIcon(_audio ? Icons.audiotrack_outlined : Icons.subtitles_outlined, list.length),
-        onPressed: () => _open(context, list),
-      ),
-    );
-  }
-
-  Future<void> _open(BuildContext context, List<MpvTrack> list) async {
-    final position = _menuPosition(context);
-    onMenuOpen?.call(true);
-    final pick = await showMenu<TrackPick>(
-      context: context,
-      position: position,
-      popUpAnimationStyle: AnimationStyle.noAnimation,
-      constraints: const BoxConstraints(minWidth: 280, maxWidth: 460),
-      items: [
-        if (!_audio)
-          CheckedPopupMenuItem(
-            value: (aid: null, sid: null, subtitlesOff: true),
-            checked: !list.any((t) => t.selected),
-            height: 36,
-            child: const Text('Off'),
-          ),
-        if (_audio && list.isEmpty)
-          const PopupMenuItem(enabled: false, height: 32, child: Text('None')),
-        for (final t in list)
-          CheckedPopupMenuItem(
-            value: _audio
-                ? (aid: t.id, sid: null, subtitlesOff: false)
-                : (aid: null, sid: t.id, subtitlesOff: false),
-            checked: t.selected,
-            height: 36,
-            child: Text(t.label, maxLines: 1, overflow: TextOverflow.ellipsis),
-          ),
-      ],
-    );
-    onMenuOpen?.call(false);
-    if (pick != null) onPick(pick);
-  }
-}
-
-/// "1:30" in the controls: skip forward [fallbackSkip] (Shift+Right).
-class SkipForwardButton extends StatelessWidget {
-  final VoidCallback onPressed;
-  final FocusNode? focusNode;
-  const SkipForwardButton({super.key, required this.onPressed, this.focusNode});
-
-  @override
-  Widget build(BuildContext context) {
-    return Tooltip(
-      message: 'Skip 1:30 for everyone (Shift+Right)',
-      child: TextButton.icon(
-        key: const ValueKey('skip-forward-button'),
-        focusNode: focusNode,
-        style: TextButton.styleFrom(
-          foregroundColor: Colors.white,
-          padding: const EdgeInsets.symmetric(horizontal: 8),
-          tapTargetSize: MaterialTapTargetSize.shrinkWrap,
-        ),
-        onPressed: onPressed,
-        icon: const Icon(Icons.fast_forward_rounded, size: 16),
-        label: const Text('1:30', style: TextStyle(fontSize: 12)),
-      ),
-    );
-  }
-}
-
-/// Floating pill over the video (Next episode, Skip OP / ED / 1:30):
-/// faint at rest, lit on hover. Lives outside the auto-hiding controls, so
-/// it shows in fullscreen and with the controls hidden.
+/// The player's action pill (Next episode, Skip OP / ED / 1:30): the
+/// status pill's glass ([AppGlass.pill]) at [height], faint at rest, lit
+/// on hover. Lives in the player's action area, outside the auto-hiding
+/// controls (also in fullscreen); `PillGate` shows it with them.
 class FloatingPill extends StatefulWidget {
+  /// Every action pill's height: the status pill's without avatars.
+  static const height = 44.0;
   final String label;
   final String tooltip;
   final IconData icon;
@@ -540,7 +25,7 @@ class FloatingPill extends StatefulWidget {
     required this.label,
     required this.tooltip,
     required this.onPressed,
-    this.icon = Icons.chevron_right,
+    this.icon = Icons.chevron_right_rounded,
     this.tapKey,
   });
 
@@ -553,38 +38,31 @@ class _FloatingPillState extends State<FloatingPill> {
 
   @override
   Widget build(BuildContext context) {
-    final primary = Theme.of(context).colorScheme.primary;
+    const fade = Duration(milliseconds: 150);
     return MouseRegion(
       cursor: SystemMouseCursors.click,
       onEnter: (_) => setState(() => _hover = true),
       onExit: (_) => setState(() => _hover = false),
       child: Tooltip(
         message: widget.tooltip,
-        child: AnimatedScale(
-          duration: const Duration(milliseconds: 150),
-          scale: _hover ? 1.06 : 1,
-          child: AnimatedOpacity(
-            duration: const Duration(milliseconds: 150),
-            opacity: _hover ? 1 : 0.45,
-            child: GestureDetector(
-              key: widget.tapKey,
-              onTap: widget.onPressed,
+        child: AnimatedOpacity(
+          duration: fade,
+          opacity: _hover ? 1 : 0.45,
+          child: GestureDetector(
+            key: widget.tapKey,
+            onTap: widget.onPressed,
+            child: AppGlass.pill(
               child: AnimatedContainer(
-                duration: const Duration(milliseconds: 150),
-                padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 9),
-                decoration: BoxDecoration(
-                  color: Colors.black.withValues(alpha: 0.75),
-                  borderRadius: BorderRadius.circular(999),
-                  border: Border.all(color: _hover ? primary : Colors.white24),
-                  boxShadow: _hover
-                      ? [BoxShadow(color: primary.withValues(alpha: 0.45), blurRadius: 16)]
-                      : const [],
-                ),
+                duration: fade,
+                height: FloatingPill.height,
+                padding: const EdgeInsets.only(left: 16, right: 12),
+                color: _hover ? Colors.white12 : Colors.transparent,
                 child: Row(
                   mainAxisSize: MainAxisSize.min,
                   children: [
-                    Text(widget.label, style: const TextStyle(color: Colors.white, fontSize: 13)),
-                    const SizedBox(width: 4),
+                    Text(widget.label,
+                        style: const TextStyle(color: Colors.white, fontSize: 14, fontWeight: FontWeight.w600)),
+                    const SizedBox(width: 6),
                     Icon(widget.icon, color: Colors.white, size: 18),
                   ],
                 ),

apps/desktop/lib/src/session/app_events.dart

@@ -0,0 +1,305 @@
+import 'package:sync_relay_core/core.dart' show FeedMessage;
+
+// Everything that may become a toast, a sound, an attention request or an
+// activity-log line, as one sealed type. Code that has news emits an
+// event ([Notifier.notify]); only the notifier decides what the user sees
+// and hears. Pure Dart (no Flutter): it can move to core with the policy.
+
+sealed class AppEvent {
+  const AppEvent();
+}
+
+// ---------------------------------------------------------------- feed
+
+/// A server `feed` line (see PROTOCOL.md, `feed.action`); every one lands
+/// in the activity log.
+sealed class FeedEvent extends AppEvent {
+  final FeedMessage feed;
+  /// This member is the actor (its own chat, ready, queue add...).
+  final bool own;
+  const FeedEvent(this.feed, {this.own = false});
+
+  String get actor => feed.actor;
+
+  /// [feed] as its typed event. [selfId]: this member's id (people are
+  /// matched by `actorId` / `targetId`, never by name); [readyCount]:
+  /// members ready in the latest state (the pitch of a `ready` sound);
+  /// [queueThumb]: the picture hash of the Up next item a `queue-add`
+  /// added (from the state that came with it), '' when none.
+  factory FeedEvent.of(FeedMessage f, {String selfId = '', int readyCount = 0, String queueThumb = ''}) {
+    bool isSelf(String id) => selfId.isNotEmpty && id == selfId;
+    final own = isSelf(f.actorId);
+    return switch (f.action) {
+      'join' => MemberJoined(f, own: own),
+      'leave' => MemberLeft(f, own: own),
+      'gone' => MemberGone(f, own: own),
+      'return' => MemberReturned(f, own: own),
+      'away' => MemberSatOut(f,
+          own: own,
+          atYou: isSelf(f.targetId) && !isSelf(f.actorId),
+          autoSelf: isSelf(f.actorId) && f.targetId.isEmpty && f.reason.isNotEmpty),
+      'in' => MemberBack(f, own: own),
+      'ready' => ReadyChanged(f, own: own, ready: true, readyIndex: readyCount),
+      'unready' => ReadyChanged(f, own: own, ready: false),
+      'force-ready' => ForcedReady(f, own: own, ready: true),
+      'force-unready' => ForcedReady(f, own: own, ready: false),
+      'force-play' => ForcedTransport(f, own: own, play: true),
+      'force-hold' => ForcedTransport(f, own: own, play: false),
+      'swap' => MediaSwapped(f, own: own),
+      'seek' => Seeked(f, own: own),
+      'pause' => Paused(f, own: own),
+      'resume' => Resumed(f, own: own),
+      'finished' => Finished(f, own: own),
+      'chat' => ChatPosted(f, own: own),
+      'rename' => MemberRenamed(f, own: own),
+      'avatar' => AvatarChanged(f, own: own),
+      'queue-add' => QueueAdded(f, own: own, thumb: queueThumb),
+      'queue-remove' => QueueRemoved(f, own: own),
+      'queue-skip' => QueueSkipped(f, own: own),
+      'fetch-fail' => FetchFailed(f, own: own),
+      _ => OtherFeed(f, own: own),
+    };
+  }
+}
+
+class MemberJoined extends FeedEvent {
+  const MemberJoined(super.feed, {super.own});
+}
+
+/// Left for good (`reason` `bye`: the app closed or Leave; `grace`: gone
+/// too long).
+class MemberLeft extends FeedEvent {
+  const MemberLeft(super.feed, {super.own});
+}
+
+/// Lost signal: gone for a while, kept in its grace period.
+class MemberGone extends FeedEvent {
+  const MemberGone(super.feed, {super.own});
+}
+
+/// Back within its grace after a [MemberGone].
+class MemberReturned extends FeedEvent {
+  const MemberReturned(super.feed, {super.own});
+}
+
+/// Someone sat out (`away`: the actor itself, or `target` sat out by the
+/// actor; `reason` `idle` / `minimised` for an automatic one); [atYou]:
+/// someone else sat this member out; [autoSelf]: this app's auto sit-out
+/// set this member away.
+class MemberSatOut extends FeedEvent {
+  final bool atYou;
+  final bool autoSelf;
+  const MemberSatOut(super.feed, {super.own, this.atYou = false, this.autoSelf = false});
+}
+
+/// Back from sitting out (`in`).
+class MemberBack extends FeedEvent {
+  const MemberBack(super.feed, {super.own});
+}
+
+class ReadyChanged extends FeedEvent {
+  final bool ready;
+  /// Members ready when it came (pitch of the ready sound).
+  final int readyIndex;
+  const ReadyChanged(super.feed, {super.own, required this.ready, this.readyIndex = 0});
+}
+
+class ForcedReady extends FeedEvent {
+  final bool ready;
+  const ForcedReady(super.feed, {super.own, required this.ready});
+}
+
+/// Force play / hold.
+class ForcedTransport extends FeedEvent {
+  final bool play;
+  const ForcedTransport(super.feed, {super.own, required this.play});
+}
+
+class MediaSwapped extends FeedEvent {
+  const MediaSwapped(super.feed, {super.own});
+}
+
+class Seeked extends FeedEvent {
+  const Seeked(super.feed, {super.own});
+}
+
+class Paused extends FeedEvent {
+  const Paused(super.feed, {super.own});
+}
+
+class Resumed extends FeedEvent {
+  const Resumed(super.feed, {super.own});
+}
+
+class Finished extends FeedEvent {
+  const Finished(super.feed, {super.own});
+}
+
+/// A chat message (`reason` carries the text); [own]: this member sent it.
+class ChatPosted extends FeedEvent {
+  const ChatPosted(super.feed, {super.own});
+}
+
+class MemberRenamed extends FeedEvent {
+  const MemberRenamed(super.feed, {super.own});
+}
+
+class AvatarChanged extends FeedEvent {
+  const AvatarChanged(super.feed, {super.own});
+}
+
+/// Someone added an item to Up next (`target` its title); [thumb]: the
+/// item's picture hash ('' when none).
+class QueueAdded extends FeedEvent {
+  final String thumb;
+  const QueueAdded(super.feed, {super.own, this.thumb = ''});
+}
+
+class QueueRemoved extends FeedEvent {
+  const QueueRemoved(super.feed, {super.own});
+}
+
+/// Up next skipped an item (`target` its title, `reason` why).
+class QueueSkipped extends FeedEvent {
+  const QueueSkipped(super.feed, {super.own});
+}
+
+/// The server could not fetch the current media.
+class FetchFailed extends FeedEvent {
+  const FetchFailed(super.feed, {super.own});
+}
+
+/// An action this app does not know (a newer server).
+class OtherFeed extends FeedEvent {
+  const OtherFeed(super.feed, {super.own});
+}
+
+// -------------------------------------------------------------- session
+
+/// Someone poked this member.
+class Nudged extends AppEvent {
+  /// Their name; '' when unknown.
+  final String name;
+  const Nudged(this.name);
+}
+
+/// Another member's player cannot open the current media.
+class MemberCantPlay extends AppEvent {
+  final String name;
+  final String error;
+  const MemberCantPlay(this.name, this.error);
+}
+
+/// This member passes the video on slower than it plays.
+class SlowSource extends AppEvent {
+  final String text;
+  const SlowSource(this.text);
+}
+
+/// This member started passing the video on through the server.
+class RelayStarted extends AppEvent {
+  const RelayStarted();
+}
+
+class RelayFailed extends AppEvent {
+  final String error;
+  const RelayFailed(this.error);
+}
+
+/// The connection to the server dropped and stayed down a few seconds
+/// (once per drop).
+class ConnectionLost extends AppEvent {
+  const ConnectionLost();
+}
+
+/// It came back after [ConnectionLost].
+class ConnectionBack extends AppEvent {
+  const ConnectionBack();
+}
+
+/// The server refused something this app sent (`err`: Up next is full, a
+/// forbidden action...).
+class ServerRefused extends AppEvent {
+  final String text;
+  const ServerRefused(this.text);
+}
+
+/// The member passing the current video on has been gone a few seconds
+/// ([left]: it left the server); viewers play what the server has.
+class RelaySourceDropped extends AppEvent {
+  final String name;
+  final bool left;
+  const RelaySourceDropped(this.name, {this.left = false});
+}
+
+/// The current media started playing for the first time ("starting
+/// now"; [title]: what plays, '' when unknown).
+class PlaybackStarted extends AppEvent {
+  final String title;
+  const PlaybackStarted(this.title);
+}
+
+/// A reconnect found the server restarted (another `welcome.instance`).
+class ServerRestarted extends AppEvent {
+  const ServerRestarted();
+}
+
+/// Another window of this install took the member over (`replaced`).
+class Replaced extends AppEvent {
+  const Replaced();
+}
+
+/// Jellyfin progress reports fail (once per media).
+class JellyfinProgressFailed extends AppEvent {
+  final bool signInExpired;
+  const JellyfinProgressFailed({required this.signInExpired});
+}
+
+// ------------------------------------------------------------------ app
+
+/// The player's shader message (a preset change, shaders turned off).
+class ShaderMessage extends AppEvent {
+  final String text;
+  const ShaderMessage(this.text);
+}
+
+/// This app added an item to Up next.
+class AddedToUpNext extends AppEvent {
+  final String title;
+  const AddedToUpNext(this.title);
+}
+
+/// Putting something up or adding it to Up next failed ([text]: why).
+class ActionFailed extends AppEvent {
+  final String text;
+  const ActionFailed(this.text);
+}
+
+/// The Schedule tab's request results and errors.
+class ScheduleResult extends AppEvent {
+  final String text;
+  const ScheduleResult(this.text);
+}
+
+/// "Mark a problem" done; [inSession]: in the server's session log.
+class ProblemMarked extends AppEvent {
+  final bool inSession;
+  const ProblemMarked({required this.inSession});
+}
+
+/// Something went on the clipboard ([text]: the confirmation, e.g.
+/// "Link copied").
+class Copied extends AppEvent {
+  final String text;
+  const Copied(this.text);
+}
+
+class CopyFailed extends AppEvent {
+  const CopyFailed();
+}
+
+/// A newer release is out (the update band shows it).
+class UpdateAvailable extends AppEvent {
+  final String version;
+  const UpdateAvailable(this.version);
+}

apps/desktop/lib/src/session/auto_sit_out.dart

@@ -0,0 +1,126 @@
+import 'package:sync_relay_core/core.dart' show Presence, PresenceReason;
+
+import '../platform/ports/shell_port.dart' show WindowActivity;
+
+/// The auto sit-out timings, in one place.
+abstract final class AutoSitOutTimes {
+  /// Not playing and no input for this long: away (`idle`). Watching
+  /// counts as activity, so a pause after a long watch starts fresh.
+  static const idle = Duration(minutes: 5);
+
+  /// Minimised (or hidden) for this long, playing or not: away
+  /// (`minimised`).
+  static const minimised = Duration(minutes: 10);
+}
+
+/// What [AutoSitOut.tick] asks the session to do.
+sealed class AutoSitOutStep {
+  const AutoSitOutStep();
+}
+
+/// Nothing to do.
+final class AutoStay extends AutoSitOutStep {
+  const AutoStay();
+}
+
+/// Sit this member out (`presence` `away` with [reason]).
+final class AutoAway extends AutoSitOutStep {
+  final PresenceReason reason;
+  const AutoAway(this.reason);
+}
+
+/// Bring this member back `in`: it was set away automatically and the
+/// user is back.
+final class AutoBack extends AutoSitOutStep {
+  const AutoBack();
+}
+
+/// Auto sit-out: idle for
+/// [AutoSitOutTimes.idle] while nothing plays, or minimised for
+/// [AutoSitOutTimes.minimised] (playing or not), sets this member away;
+/// input or the window's focus brings it back, but only from an away
+/// this set ([autoAway]); a manual away (own or someone else's) stays.
+/// Never when alone (nobody to hold up or to tell). Pure: the session
+/// feeds it input, window changes and a 1 s [tick].
+class AutoSitOut {
+  final Duration idleAfter;
+  final Duration minimisedAfter;
+  AutoSitOut(DateTime now,
+      {this.idleAfter = AutoSitOutTimes.idle, this.minimisedAfter = AutoSitOutTimes.minimised})
+      : _lastActive = now;
+
+  DateTime _lastActive;
+  DateTime? _minimisedSince;
+  bool _activitySinceAway = false;
+  bool _autoAway = false;
+  // An away sent, not yet seen in a state.
+  DateTime? _sentAt;
+  static const _echoWait = Duration(seconds: 10);
+
+  /// The member is away because this set it (not by hand, not someone
+  /// else).
+  bool get autoAway => _autoAway;
+
+  /// Keyboard, mouse or any action in the app.
+  void input(DateTime now) {
+    _lastActive = now;
+    _activitySinceAway = true;
+  }
+
+  /// The window's focus or visibility changed.
+  void window(WindowActivity a, DateTime now) {
+    switch (a) {
+      case WindowActivity.minimised:
+      case WindowActivity.hidden:
+        _minimisedSince ??= now;
+      case WindowActivity.focused:
+        _minimisedSince = null;
+        input(now);
+      case WindowActivity.unfocused:
+        _minimisedSince = null;
+    }
+  }
+
+  /// The user sat out (or came back) by hand: an away is no longer ours.
+  void manual() {
+    _autoAway = false;
+    _sentAt = null;
+  }
+
+  /// Once a second. [self]: this member's presence in the latest state
+  /// (null: not in one); [alone]: nobody else connected ([isAlone]);
+  /// [enabled]: the setting (and not a solo session).
+  AutoSitOutStep tick(DateTime now,
+      {required Presence? self, required bool playing, required bool alone, required bool enabled}) {
+    if (playing) _lastActive = now;
+    if (self == null || self == Presence.gone) return const AutoStay();
+    if (self != Presence.away) {
+      final sent = _sentAt;
+      if (sent != null && now.difference(sent) < _echoWait) return const AutoStay();
+      _sentAt = null;
+      _autoAway = false;
+    } else {
+      _sentAt = null;
+      if (_autoAway && _activitySinceAway && _minimisedSince == null) {
+        _autoAway = false;
+        return const AutoBack();
+      }
+      return const AutoStay();
+    }
+    if (!enabled || alone) return const AutoStay();
+    final since = _minimisedSince;
+    final PresenceReason? reason;
+    if (since != null && now.difference(since) >= minimisedAfter) {
+      reason = PresenceReason.minimised;
+    } else if (!playing && now.difference(_lastActive) >= idleAfter) {
+      reason = PresenceReason.idle;
+    } else {
+      reason = null;
+    }
+    if (reason == null) return const AutoStay();
+    _autoAway = true;
+    _activitySinceAway = false;
+    _sentAt = now;
+    return AutoAway(reason);
+  }
+}

apps/desktop/lib/src/session/connection.dart

@@ -0,0 +1,708 @@
+import 'dart:async';
+import 'dart:io';
+import 'dart:math';
+
+import 'package:flutter/foundation.dart' show debugPrint;
+import 'package:signals/signals_core.dart';
+import 'package:sync_relay_core/core.dart';
+
+import '../screens/home/ui.dart' show appName, displayVersion;
+import '../state/settings.dart';
+import '../sync/sync_client.dart';
+import 'app_events.dart';
+import 'identity.dart' show ClientIdentity;
+
+/// Thrown when a connect is superseded by cancel/leave before it finished.
+class ConnectCancelled implements Exception {
+  const ConnectCancelled();
+  @override
+  String toString() => 'connection cancelled';
+}
+
+class ConnectParams {
+  final String host;
+  final int port;
+  final String secret;
+  final String name;
+  final String avatar;
+  final String mediaPath;
+  final String linkUrl;
+  /// Sent in hello by the hosting app's own client (see AppConfig.hostKey).
+  final String hostKey;
+  /// Put up with a `swap` right after joining (a Jellyfin ref or a link);
+  /// wins over [linkUrl].
+  final HelloMedia? media;
+  const ConnectParams({
+    required this.host,
+    required this.port,
+    required this.secret,
+    required this.name,
+    this.avatar = '',
+    this.mediaPath = '',
+    this.linkUrl = '',
+    this.hostKey = '',
+    this.media,
+  });
+
+  ConnectParams withMedia(HelloMedia? media) => ConnectParams(
+        host: host,
+        port: port,
+        secret: secret,
+        name: name,
+        avatar: avatar,
+        mediaPath: mediaPath,
+        linkUrl: media == null ? linkUrl : '',
+        hostKey: hostKey,
+        media: media,
+      );
+
+  ConnectParams withProfile({String? name, String? avatar}) => ConnectParams(
+        host: host,
+        port: port,
+        secret: secret,
+        name: name ?? this.name,
+        avatar: avatar ?? this.avatar,
+        mediaPath: mediaPath,
+        linkUrl: linkUrl,
+        hostKey: hostKey,
+        media: media,
+      );
+}
+
+/// Where the [Connection] is. Each change is a new value (a repeat is
+/// notified too).
+sealed class ConnState {
+  const ConnState();
+
+  /// The reconnect loop runs ([ConnLost] or [ConnReconnecting]).
+  bool get retrying => false;
+
+  /// A welcomed socket is up ([ConnOnline] or [ConnUnstable]): what the
+  /// server says is current.
+  bool get online => false;
+}
+
+/// Not connected and not trying: before the first connect, after leave,
+/// cancel or "stop reconnecting".
+final class ConnClosed extends ConnState {
+  const ConnClosed();
+  @override
+  String toString() => 'closed';
+}
+
+/// The first dial of a session (hello sent, waiting for welcome).
+final class ConnConnecting extends ConnState {
+  const ConnConnecting();
+  @override
+  String toString() => 'connecting';
+}
+
+/// Welcome received; frames arrive.
+final class ConnOnline extends ConnState {
+  const ConnOnline();
+  @override
+  bool get online => true;
+  @override
+  String toString() => 'online';
+}
+
+/// Still the same socket, but nothing came for [Connection.unstableAfter]
+/// (the server sends a state every second): the link may be dying. Back
+/// to [ConnOnline] with the next frame, [ConnLost] at
+/// [Connection.silenceLimit].
+final class ConnUnstable extends ConnState {
+  const ConnUnstable();
+  @override
+  bool get online => true;
+  @override
+  String toString() => 'unstable';
+}
+
+/// Dropped (the socket closed, or nothing came for
+/// [Connection.silenceLimit]); the next attempt is scheduled. The session
+/// keeps what it had (the last state, the player, a relay it serves).
+final class ConnLost extends ConnState {
+  const ConnLost();
+  @override
+  bool get retrying => true;
+  @override
+  String toString() => 'lost';
+}
+
+/// Reconnect attempt [attempt] (1 is the first after the drop) is
+/// dialling; after it failed it stays until the next one, unless the
+/// socket's close said [ConnLost] meanwhile.
+final class ConnReconnecting extends ConnState {
+  final int attempt;
+  const ConnReconnecting(this.attempt);
+  @override
+  bool get retrying => true;
+  @override
+  String toString() => 'reconnecting($attempt)';
+}
+
+/// The server refused this app; nothing retries. [code]: `version` or
+/// `secret` when the server said so, else empty (offline, timeout,
+/// anything else on the first dial); [message]: in plain words
+/// ([connectErrorText]).
+final class ConnRefused extends ConnState {
+  final String code;
+  final String message;
+  const ConnRefused(this.code, this.message);
+  @override
+  String toString() => 'refused($code: $message)';
+}
+
+/// Another connection of this install holds the member (`err` `replaced`,
+/// close 4013, or this hello was `stale`): Starsync was opened in another
+/// window. Nothing retries ("Retry" takes the member back).
+final class ConnReplaced extends ConnState {
+  const ConnReplaced();
+  String get message => replacedText;
+  @override
+  String toString() => 'replaced';
+}
+
+/// [ConnReplaced] in plain words.
+const replacedText = 'Starsync was opened in another window';
+
+/// A version refusal in plain words: [err] is the server's `err`
+/// `version` (its range in `min`/`max`), or a proto 15 server's codeless
+/// `proto mismatch`, which is always an older host.
+String versionText(ErrorFrame? err) {
+  final max = err?.max, min = err?.min;
+  if (err?.code == null || (max != null && max < RelayConstants.protoMin)) {
+    return 'the host runs an older Starsync — they need to update';
+  }
+  if (min != null && min > RelayConstants.protoMax) return 'the host runs a newer Starsync — update the app';
+  return 'the host runs a different Starsync version — update both apps';
+}
+
+/// A failed dial in plain words.
+String connectErrorText(Object e) {
+  if (e is HelloRefused) {
+    final err = e.error;
+    if (err != null && err.code == null && err.message.contains('proto mismatch')) return versionText(err);
+    return switch (e.code) {
+      ErrCode.version => versionText(err),
+      ErrCode.secret => 'wrong server password (401)',
+      ErrCode.replaced || ErrCode.stale => replacedText,
+      _ => 'refused: ${err?.message ?? 'closed (${e.closeCode})'}',
+    };
+  }
+  final msg = '$e';
+  if (msg.contains('SocketException') || msg.contains('Connection refused')) {
+    return 'host offline — check address and port';
+  }
+  return 'connect failed: $e';
+}
+
+/// The terminal state a failed dial leaves, or null when another attempt
+/// may work.
+ConnState? _terminalFor(Object e, {required bool first}) {
+  if (e is HelloRefused) {
+    final err = e.error;
+    if (err != null && err.code == null && err.message.contains('proto mismatch')) {
+      return ConnRefused('version', versionText(err));
+    }
+    switch (e.code) {
+      case ErrCode.replaced:
+      case ErrCode.stale:
+        return const ConnReplaced();
+      case ErrCode.version:
+        return ConnRefused('version', connectErrorText(e));
+      case ErrCode.secret:
+        return ConnRefused('secret', connectErrorText(e));
+      default:
+        break;
+    }
+  }
+  return first ? ConnRefused('', connectErrorText(e)) : null;
+}
+
+/// What a hello says about this install besides the connect form.
+typedef HelloIdentity = ({String client, int seq, ClientCaps caps, int? feedAfter});
+
+/// Builds the `hello` for [params]. Injectable so later protocol versions
+/// add fields without changing [Connection].
+typedef HelloBuilder = HelloMessage Function(ConnectParams params, HelloIdentity id);
+
+/// Protocol 16's hello: this build's version range, the install's client
+/// id and connection count, the app version, platform and what it can do;
+/// `feedAfter` on a reconnect to the same server.
+HelloMessage defaultHello(ConnectParams params, HelloIdentity id) => HelloMessage(
+      proto: RelayConstants.protoMax,
+      protoMin: RelayConstants.protoMin,
+      secret: params.secret,
+      user: HelloUser(name: params.name, avatar: params.avatar),
+      hostKey: params.hostKey,
+      client: id.client,
+      seq: id.seq,
+      app: appVersion,
+      platform: Platform.operatingSystem,
+      caps: id.caps,
+      feedAfter: id.feedAfter,
+    );
+
+/// How a welcome relates to the member this app held before.
+typedef Rejoin = ({
+  /// A reconnect of the running session (not its first dial).
+  bool reconnect,
+  /// `welcome.resumed`: the same member, everything kept.
+  bool resumed,
+  /// The same server boot as the last welcome (`welcome.instance`).
+  bool sameServer,
+  /// The token the session held before this welcome ('' on the first).
+  String oldToken,
+});
+
+/// The session's part of a welcome, called before its state goes out
+/// (see [Connection.onWelcome]).
+typedef WelcomeHandler = void Function(WelcomeMessage welcome, Rejoin rejoin);
+
+/// The link to the server: the [SyncClient] socket, the first connect,
+/// reconnects (backoff with jitter between attempts, epochs that make a
+/// cancelled attempt stale), the silence policy ("unstable" after
+/// [unstableAfter] without a frame, lost at [silenceLimit]), the 1 s
+/// heartbeat (clock ping, which also keeps this member under the
+/// server's silence limit, and diagnostics), the connection lost/back
+/// events and [state]. The install's identity rides in every hello
+/// ([identity]); what a welcome means to the session is its [onWelcome].
+class Connection {
+  final SyncClient client;
+  /// Where [ConnectionLost] / [ConnectionBack] go (the Notifier).
+  final void Function(AppEvent event) _notify;
+  /// Builds each dial's hello.
+  final HelloBuilder hello;
+  /// `hello.client` / `hello.seq` (the stored one in the app; a fresh
+  /// in-memory one by default, so every test connection is its own
+  /// install).
+  final ClientIdentity identity;
+  /// `hello.caps` at each dial (the session sets it).
+  ClientCaps Function() caps;
+  /// Wait before the first reconnect attempt; it doubles per failed
+  /// attempt up to [maxReconnectDelay], each with ±20 % jitter.
+  final Duration reconnectDelay;
+  final Duration maxReconnectDelay;
+  /// No frame for this long: [ConnUnstable].
+  final Duration unstableAfter;
+  /// No frame for this long means the connection is lost.
+  final Duration silenceLimit;
+  /// The lost sound plays only once a drop lasted this long (a quick
+  /// reconnect says nothing, and no lost/back pair per flap).
+  final Duration lostSoundAfter;
+  /// The clock the silence and the lost sound are measured on (UTC; a
+  /// test passes a fake one). The heartbeat that checks it stays a real
+  /// 1 s timer.
+  final DateTime Function() now;
+  final Random _random;
+
+  Connection(
+      {void Function(AppEvent event)? notify,
+      SyncClient? client,
+      this.hello = defaultHello,
+      ClientIdentity? identity,
+      ClientCaps Function()? caps,
+      this.reconnectDelay = const Duration(seconds: 1),
+      this.maxReconnectDelay = const Duration(seconds: 15),
+      this.unstableAfter = const Duration(seconds: 3),
+      this.silenceLimit = const Duration(seconds: 9),
+      this.lostSoundAfter = const Duration(seconds: 4),
+      DateTime Function()? now,
+      Random? random})
+      : _notify = notify ?? ((_) {}),
+        now = now ?? _utcNow,
+        identity = identity ?? ClientIdentity.ephemeral(),
+        caps = caps ?? (() => const ClientCaps(source: true)),
+        _random = random ?? Random(),
+        client = client ?? SyncClient() {
+    this.client.onFrame = () => _lastFrameAt = this.now();
+    _subs = [
+      this.client.status.listen(_onStatus),
+      this.client.errors.listen(_onError),
+    ];
+  }
+
+  late final List<StreamSubscription> _subs;
+
+  static DateTime _utcNow() => DateTime.now().toUtc();
+
+  final _state = signal<ConnState>(const ConnClosed());
+  /// Every change is notified, a repeat too.
+  ReadonlySignal<ConnState> get state => _state;
+
+  /// Set by the session (see [WelcomeHandler]).
+  WelcomeHandler? onWelcome;
+
+  /// This app's log lines to the server's session log (Settings: "Share
+  /// diagnostics with the server"), and "Mark a problem". Runs from
+  /// [begin] to [close].
+  late final DiagUploader diag = DiagUploader(
+      target: _diagTarget, version: '$appName ${displayVersion()} on ${Platform.operatingSystem}');
+
+  DiagTarget? _diagTarget() {
+    final uri = client.wsUri;
+    if (client.token.isEmpty || uri == null || !client.clockSync.hasSample) return null;
+    return (base: DiagUploader.baseOf(uri), token: client.token, offsetMs: client.clockSync.offsetMs);
+  }
+
+  ConnectParams? _params;
+  /// The last connect's parameters (with [updateProfile]'s changes); a
+  /// reconnect dials with them.
+  ConnectParams? get params => _params;
+
+  // Bumped by every connect/leave/cancel/retry: stale attempts no-op.
+  int _epoch = 0;
+  Timer? _reconnectTimer;
+  Timer? _heartbeat;
+  // Set by close/cancel/a terminal refusal: no reconnect, no lost detection.
+  bool _closed = false;
+  bool _everOnline = false;
+  /// The connection-lost sound played; the reconnected one answers it once.
+  bool _lostSounded = false;
+  DateTime? _lastFrameAt;
+  /// When the current drop began (the last frame for a silent link).
+  DateTime? _droppedAt;
+  int _attempt = 0;
+  /// Non-terminal `err` frames, in plain words.
+  final _errorTexts = StreamController<String>.broadcast();
+
+  // The socket and what the server said, read through.
+  Stream<StateBroadcast> get states => client.states;
+  /// Feed entries, chat included; replayed ones after a reconnect.
+  Stream<FeedMessage> get feeds => client.feeds;
+  Stream<NudgeNotice> get nudges => client.nudges;
+  /// `err` frames after the welcome (a `replaced` one ends the connection
+  /// instead).
+  Stream<String> get errors => _errorTexts.stream;
+  String get token => client.token;
+  String get memberId => client.memberId;
+  /// This member's `/j/...` URL from `welcome`.
+  String? get relayUrl => client.relayUrl;
+  StateBroadcast? get lastState => client.lastState;
+  /// Now on the server's clock (the ping/pong clock offset).
+  DateTime serverNow() => client.serverNow();
+
+  void sendReady(bool ready, {String source = 'manual'}) => client.sendReady(ready, source: source);
+  void sendForce(String target, bool ready) => client.sendForce(target, ready);
+  void sendSeek(double position, {int seq = 0}) => client.sendSeek(position, seq: seq);
+  void sendSwap(HelloMedia media, {String? queueId}) => client.sendSwap(media, queueId: queueId);
+  void sendQueue(QueueIntent intent) => client.sendQueue(intent);
+  void sendReport({
+    required double position,
+    required double buffered,
+    required int eventId,
+    double duration = 0,
+    int mediaId = 0,
+    Map<String, bool>? jf,
+    String error = '',
+  }) =>
+      client.sendReport(
+          position: position,
+          buffered: buffered,
+          eventId: eventId,
+          duration: duration,
+          mediaId: mediaId,
+          jf: jf,
+          error: error);
+  void sendChat(String text) => client.sendChat(text);
+  void sendArt(int mediaId, {String? poster, String? banner}) =>
+      client.sendArt(mediaId, poster: poster, banner: banner);
+  void sendPresence(PresenceIntent intent) => client.sendPresence(intent);
+  void sendNudge(String target) => client.sendNudge(target);
+
+  /// Name and/or picture change for everyone now; reconnects send them too.
+  void updateProfile({String? name, String? avatar}) {
+    _params = _params?.withProfile(name: name, avatar: avatar);
+    client.sendProfile(name: name, avatar: avatar);
+  }
+
+  /// A new epoch: attempts in flight become stale, a scheduled reconnect
+  /// is dropped. Returns it.
+  int invalidate() {
+    _epoch++;
+    _reconnectTimer?.cancel();
+    _reconnectTimer = null;
+    return _epoch;
+  }
+
+  /// False once a cancel, retry, leave or new connect followed [epoch].
+  bool isCurrent(int epoch) => epoch == _epoch;
+
+  /// A new session with [params]: forgets the last one's server and
+  /// starts the diagnostics. [dial] connects.
+  void begin(ConnectParams params) {
+    _params = params;
+    _closed = false;
+    _everOnline = false;
+    _lostSounded = false;
+    _droppedAt = null;
+    _attempt = 0;
+    diag
+      ..share = AppSettings.instance.shareDiagnostics.peek()
+      ..start();
+  }
+
+  /// The first dial of the session [begin] started. Throws
+  /// [ConnectCancelled] when [epoch] went stale meanwhile (whoever bumped
+  /// it also closed the socket); any other failure leaves [state] refused
+  /// (or replaced).
+  Future<WelcomeMessage> dial(int epoch) async {
+    final params = _params!;
+    _set(const ConnConnecting());
+    try {
+      final welcome = await _connect(params, reconnect: false);
+      if (epoch != _epoch) throw const ConnectCancelled();
+      _online();
+      return welcome;
+    } catch (e) {
+      if (epoch != _epoch) throw const ConnectCancelled();
+      debugPrint('connect failed: $e');
+      _set(_terminalFor(e, first: true)!);
+      rethrow;
+    }
+  }
+
+  Future<WelcomeMessage> _connect(ConnectParams params, {required bool reconnect}) {
+    final oldToken = client.token;
+    final before = client.instance;
+    final id = (
+      client: identity.clientId,
+      seq: identity.nextSeq(),
+      caps: caps(),
+      feedAfter: reconnect && before.isNotEmpty && client.lastFeedSeq > 0 ? client.lastFeedSeq : null,
+    );
+    return client.connectWith(
+      wsUri: _wsUri(params),
+      hello: hello(params, id),
+      onWelcome: (w) {
+        _lastFrameAt = now();
+        onWelcome?.call(w, (
+          reconnect: reconnect,
+          resumed: w.resumed,
+          sameServer: before.isNotEmpty && before == w.instance,
+          oldToken: oldToken,
+        ));
+      },
+    );
+  }
+
+  static Uri _wsUri(ConnectParams p) => Uri.parse('ws://${p.host}:${p.port}/sync');
+
+  void _online() {
+    _attempt = 0;
+    _everOnline = true;
+    _droppedAt = null;
+    if (_lostSounded) {
+      _lostSounded = false;
+      _notify(const ConnectionBack());
+    }
+    _lastFrameAt = now();
+    _set(const ConnOnline());
+    _heartbeat ??= Timer.periodic(const Duration(seconds: 1), (_) => _beat());
+  }
+
+  void _set(ConnState s) => _state.set(s, force: true);
+
+  void _onStatus(SyncStatus s) {
+    // Before the first welcome a close is just the dial failing; during a
+    // reconnect attempt the attempt reports it. A socket error (a reset
+    // link) may come without a close.
+    if (s != SyncStatus.closed && s != SyncStatus.error) return;
+    if (_closed || !_everOnline || !_state.peek().online) return;
+    switch (s == SyncStatus.closed ? client.closeCode : null) {
+      case CloseCodes.replaced:
+      case CloseCodes.stale:
+        _end(const ConnReplaced());
+      case CloseCodes.version:
+        _end(ConnRefused('version', versionText(null)));
+      case CloseCodes.secret:
+        _end(const ConnRefused('secret', 'wrong server password (401)'));
+      default:
+        _dropped(now());
+    }
+  }
+
+  void _onError(ErrorFrame e) {
+    if (e.code == ErrCode.replaced) {
+      _end(const ConnReplaced());
+      return;
+    }
+    if (!_errorTexts.isClosed) _errorTexts.add(e.message);
+  }
+
+  /// A terminal state: no more attempts, the socket goes.
+  void _end(ConnState s) {
+    debugPrint('connection ended: $s');
+    _halt(s);
+    unawaited(client.drop());
+  }
+
+  /// Lost since [since]: the socket goes, a reconnect is scheduled (unless
+  /// one already is or dials).
+  void _dropped(DateTime since) {
+    if (_closed || _state.peek().retrying) return;
+    _droppedAt = since;
+    unawaited(client.drop());
+    scheduleReconnect();
+  }
+
+  /// Every second once online: a ping (a clock sample; it also keeps this
+  /// member under the server's silence limit while nothing else is sent),
+  /// the diagnostics, the silence check and the delayed lost sound.
+  void _beat() {
+    final t = now();
+    final s = _state.peek();
+    if (s.online) client.sendPing();
+    diag
+      ..share = AppSettings.instance.shareDiagnostics.peek()
+      ..tick();
+    if (_closed) return;
+    final last = _lastFrameAt;
+    if (s.online && last != null) {
+      final quiet = t.difference(last);
+      if (quiet >= silenceLimit) {
+        debugPrint('connection: nothing for ${quiet.inSeconds} s; reconnecting');
+        _dropped(last);
+      } else if (quiet >= unstableAfter) {
+        if (s is ConnOnline) _set(const ConnUnstable());
+      } else if (s is ConnUnstable) {
+        _set(const ConnOnline());
+      }
+    }
+    final since = _droppedAt;
+    if (_state.peek().retrying && since != null && !_lostSounded && t.difference(since) >= lostSoundAfter) {
+      _lostSounded = true;
+      _notify(const ConnectionLost());
+    }
+  }
+
+  /// Reconnect after the backoff ([state] lost), unless closed, never
+  /// online (unless [manual]) or already retrying.
+  void scheduleReconnect({bool manual = false}) {
+    if (_closed || _params == null) return;
+    if (!manual && !_everOnline) return;
+    if (_state.peek().retrying) return;
+    _droppedAt ??= now();
+    _set(const ConnLost());
+    _armReconnect();
+  }
+
+  /// The wait before attempt [attempt] (1 = the first after a drop).
+  Duration delayFor(int attempt) {
+    final base = reconnectDelay.inMilliseconds * pow(2, max(0, attempt - 1));
+    final capped = min(base.toDouble(), maxReconnectDelay.inMilliseconds.toDouble());
+    return Duration(milliseconds: (capped * (0.8 + 0.4 * _random.nextDouble())).round());
+  }
+
+  void _armReconnect() {
+    final epoch = _epoch;
+    _reconnectTimer?.cancel();
+    _reconnectTimer = Timer(delayFor(_attempt + 1), () => _reconnect(epoch));
+  }
+
+  /// One reconnect attempt. An attempt from an older epoch must not touch
+  /// state (it would kill the newer connection).
+  Future<void> _reconnect(int epoch) async {
+    _reconnectTimer = null;
+    bool stale() => epoch != _epoch;
+    final params = _params;
+    if (stale() || params == null || _closed) return;
+    try {
+      _set(ConnReconnecting(++_attempt));
+      await _connect(params, reconnect: true);
+      // Whoever bumped the epoch also closed (or replaced) the socket.
+      if (stale()) return;
+      _online();
+    } catch (e) {
+      if (stale()) return;
+      debugPrint('reconnect failed: $e');
+      final end = _terminalFor(e, first: false);
+      if (end != null) {
+        _end(end);
+      } else {
+        _retryAfterFailure(e);
+      }
+    }
+  }
+
+  void _retryAfterFailure(Object e) {
+    if (_closed) {
+      _set(const ConnClosed());
+    } else if (!_everOnline) {
+      // Only a manual retry before any welcome gets here.
+      _set(_terminalFor(e, first: true)!);
+    } else {
+      if (!_state.peek().retrying) _set(const ConnLost());
+      _armReconnect();
+    }
+  }
+
+  /// "Stop reconnecting": no more attempts; one dialling is aborted.
+  void cancelReconnect() {
+    _halt(const ConnClosed());
+    unawaited(client.drop());
+  }
+
+  /// Cancel during setup: aborts the dial.
+  Future<void> cancelConnect() async {
+    _halt(const ConnClosed());
+    try {
+      await client.drop();
+    } catch (_) {}
+  }
+
+  void _halt(ConnState s) {
+    _closed = true;
+    invalidate();
+    _heartbeat?.cancel();
+    _heartbeat = null;
+    _set(s);
+  }
+
+  /// "Retry": a reconnect after the first backoff whatever the state
+  /// (after [ConnReplaced] it takes the member back from the other
+  /// window). False without a session to retry.
+  bool retry() {
+    if (_params == null) return false;
+    invalidate();
+    _closed = false;
+    _attempt = 0;
+    _set(const ConnClosed());
+    scheduleReconnect(manual: true);
+    return true;
+  }
+
+  /// No more reconnects or silence checks, [state] closed; the socket
+  /// stays until [close] (the session's last words still go out).
+  void stop() {
+    _closed = true;
+    _reconnectTimer?.cancel();
+    _reconnectTimer = null;
+    _heartbeat?.cancel();
+    _heartbeat = null;
+    _set(const ConnClosed());
+  }
+
+  /// [stop], the last diagnostics (before the token goes), with [bye] the
+  /// member's `bye` (flushed: the server's close is awaited briefly), then
+  /// the socket.
+  Future<void> close({bool bye = false}) async {
+    stop();
+    await diag.stop();
+    // A welcomed socket still open (a dead one costs the short wait).
+    if (bye && client.isOpen && client.token.isNotEmpty) await client.sendBye();
+    try {
+      await client.disconnect();
+    } catch (_) {}
+  }
+
+  Future<void> dispose() async {
+    stop();
+    for (final s in _subs) {
+      await s.cancel();
+    }
+    await _errorTexts.close();
+    await client.dispose();
+  }
+}

apps/desktop/lib/src/session/delivery.dart

@@ -0,0 +1,338 @@
+import 'package:sync_relay_core/core.dart';
+
+import '../jellyfin/session_media.dart';
+import 'party.dart';
+
+// Who fetches the current media and how it spreads, from the state alone:
+// the members card's source line and each member's route and buffer.
+
+/// `media.relay` of a state, or null when the media is not relayed.
+MediaRelay? stateMediaRelay(StateBroadcast state) {
+  final r = state.media?['relay'];
+  return r is Map ? MediaRelay.fromJson(Map<String, Object?>.from(r)) : null;
+}
+
+/// "4.1 MB/s", "850 kB/s".
+String formatRate(int bytesPerSec) {
+  if (bytesPerSec >= 1000000) {
+    final mb = bytesPerSec / 1e6;
+    return '${mb.toStringAsFixed(mb >= 10 ? 0 : 1)} MB/s';
+  }
+  return '${(bytesPerSec / 1000).round()} kB/s';
+}
+
+/// How the current media reaches the party.
+enum DeliveryKind {
+  /// A link every app opens itself.
+  link,
+  /// The hosting app's file, read by everyone from its server.
+  hostFile,
+  /// A file the dedicated server was started with.
+  serverFile,
+  /// A member's machine passes it on through the server.
+  memberRelay,
+  /// The server reads the link itself.
+  serverFetch,
+  /// Jellyfin: own accounts, the server's login for the rest.
+  jellyfin,
+}
+
+/// How a member gets the bytes.
+enum DeliveryRoute {
+  /// It serves them (a relay source, the host's file).
+  source,
+  /// It reads them from the server.
+  server,
+  /// It fetches them itself (a link, its own Jellyfin account).
+  direct,
+}
+
+enum BufferHealth { good, low, starving }
+
+/// The relay source's condition.
+enum SourceState {
+  ok,
+  /// Measured slower than the media's bitrate.
+  slow,
+  /// Its channel is down (or the server has not read the link yet).
+  waiting,
+  /// The source member's connection dropped (`gone`, within its grace):
+  /// viewers play what the server has.
+  gone,
+  /// It left the server.
+  left,
+}
+
+/// Members' names by id, kept after they leave: "Foxyz left" needs the
+/// name the state no longer has.
+class MemberNames {
+  final _names = <String, String>{};
+
+  void observe(StateBroadcast r) {
+    if (_names.length > 256) _names.clear();
+    for (final m in r.members) {
+      _names[m.id] = m.name;
+    }
+  }
+
+  String? operator [](String id) => _names[id];
+}
+
+/// The member [m]'s route and buffer.
+class MemberDelivery {
+  /// Null when unknown (a Jellyfin member that has not reported yet).
+  final DeliveryRoute? route;
+  final DeliveryKind kind;
+  /// Bytes per second the server sends it lately.
+  final int rate;
+  /// Null when it does not count: sitting out, reconnecting, cannot play.
+  final BufferHealth? health;
+  final double buffered;
+  /// The media is a Jellyfin item (direct = its own account).
+  final bool jellyfin;
+  const MemberDelivery({
+    required this.route,
+    required this.kind,
+    this.jellyfin = false,
+    required this.rate,
+    required this.health,
+    required this.buffered,
+  });
+
+  /// "via server · 3.2 MB/s", "direct", "passes it on"; empty when unknown.
+  String get short => switch (route) {
+        DeliveryRoute.source => kind == DeliveryKind.hostFile ? 'hosts the file' : 'passes it on',
+        DeliveryRoute.server => rate > 0 ? 'via server · ${formatRate(rate)}' : 'via server',
+        DeliveryRoute.direct => jellyfin ? 'own Jellyfin account' : 'direct',
+        null => '',
+      };
+
+  /// [short] and the buffer: "via server · 3.2 MB/s · 45 s buffered".
+  String get detail => [
+        if (short.isNotEmpty) short,
+        if (health != null) health == BufferHealth.starving ? 'buffer empty' : '${buffered.round()} s buffered',
+      ].join(' · ');
+}
+
+/// The current media's path for everyone: what the members card's source
+/// line says.
+class Delivery {
+  final DeliveryKind kind;
+  /// The member serving it ([DeliveryKind.memberRelay], [DeliveryKind.hostFile]); empty otherwise.
+  final String sourceId;
+  final String sourceName;
+  final bool sourceIsSelf;
+  final SourceState state;
+  /// [SourceState.gone]: since when; and the time the line is read at.
+  final DateTime? goneSince;
+  final DateTime? at;
+  /// `media.relay.rate` / `need` (0 unknown).
+  final int rate, need;
+  /// Members (not sitting out, not the source) reading from the server,
+  /// and fetching it themselves.
+  final int viaServer, direct;
+  const Delivery({
+    required this.kind,
+    this.sourceId = '',
+    this.sourceName = '',
+    this.sourceIsSelf = false,
+    this.state = SourceState.ok,
+    this.goneSince,
+    this.at,
+    this.rate = 0,
+    this.need = 0,
+    this.viaServer = 0,
+    this.direct = 0,
+  });
+
+  bool get relayed => kind == DeliveryKind.memberRelay || kind == DeliveryKind.serverFetch;
+
+  /// Rate against bitrate, both known: 1 = exactly what the media needs.
+  double? get headroom => rate > 0 && need > 0 ? rate / need : null;
+
+  String get title {
+    final who = sourceIsSelf ? 'You' : sourceName;
+    switch (kind) {
+      case DeliveryKind.link:
+        return 'Everyone plays the link directly';
+      case DeliveryKind.serverFile:
+        return 'The server has the file';
+      case DeliveryKind.hostFile:
+        return sourceIsSelf ? 'You host the file' : '$who hosts the file';
+      case DeliveryKind.jellyfin:
+        return viaServer == 0 ? 'Everyone streams it from Jellyfin' : 'From Jellyfin';
+      case DeliveryKind.serverFetch:
+        return switch (state) {
+          SourceState.waiting => 'The server is getting the video…',
+          SourceState.slow => 'The server fetches it slower than it plays',
+          _ => 'The server fetches it',
+        };
+      case DeliveryKind.memberRelay:
+        return switch (state) {
+          SourceState.left => '$sourceName left — playing what the server has',
+          SourceState.gone => sourceIsSelf
+              ? 'Reconnecting you to the server…'
+              : "$sourceName's connection dropped — playing what the server has${_for()}",
+          SourceState.waiting => sourceIsSelf ? 'Reconnecting you to the server…' : 'Waiting for $who to reconnect',
+          SourceState.slow => sourceIsSelf ? 'Your upload is slower than the video' : "$who's upload is slower than the video",
+          SourceState.ok => sourceIsSelf ? 'You pass it on through the server' : '$who passes it on through the server',
+        };
+    }
+  }
+
+  String _for() {
+    final since = goneSince, now = at;
+    if (since == null || now == null || now.difference(since).inMinutes < 1) return '';
+    return ' (${sinceText(since, now)})';
+  }
+
+  /// "3 through the server · 4.1 MB/s, needs 2.3 MB/s"; empty when
+  /// there is nothing to add.
+  String get detail {
+    final parts = <String>[
+      if (direct > 0 && (kind == DeliveryKind.jellyfin || kind == DeliveryKind.memberRelay))
+        '$direct with their own account',
+      if (viaServer > 0 && kind != DeliveryKind.link) '$viaServer through the server',
+      if (rate > 0 && state != SourceState.left && state != SourceState.gone) need > 0 ? '${formatRate(rate)}, needs ${formatRate(need)}' : formatRate(rate),
+    ];
+    return parts.join(' · ');
+  }
+
+  /// The hover text: what the numbers mean.
+  String get explain => switch (kind) {
+        DeliveryKind.memberRelay || DeliveryKind.serverFetch => [
+            if (rate > 0)
+              '${kind == DeliveryKind.serverFetch ? 'The server gets' : sourceIsSelf ? 'You send' : '$sourceName sends'} '
+                  '${formatRate(rate)} while the server asks for more.',
+            if (need > 0) 'The video averages ${formatRate(need)}.',
+            if (state == SourceState.slow) 'Slower than the video: the others will pause to buffer.',
+            if (rate == 0) 'The speed shows once bytes have flowed for a few seconds.',
+          ].join(' '),
+        DeliveryKind.hostFile || DeliveryKind.serverFile => 'Everyone else reads the file from the server.',
+        DeliveryKind.jellyfin => 'Members with an account on that Jellyfin stream it themselves; '
+            'the rest through the server.',
+        DeliveryKind.link => 'Each app opens the link itself; the server only keeps time.',
+      };
+}
+
+/// The current media's [Delivery]; null with nothing up or nobody else in
+/// the server. [names] remembers a source that left; [now] reads how long
+/// a gone source has been gone.
+Delivery? deliveryOf(StateBroadcast r, {required String selfId, MemberNames? names, DateTime? now}) {
+  final media = r.media;
+  if (media == null || r.members.length < 2) return null;
+  final rel = media['relay'];
+  final relay = rel is Map ? MediaRelay.fromJson(Map<String, Object?>.from(rel)) : null;
+  final ref = refOfStateMedia(media);
+  final url = media['url'];
+  final kind = relay != null
+      ? (relay.fetch ? DeliveryKind.serverFetch : DeliveryKind.memberRelay)
+      : ref != null
+          ? DeliveryKind.jellyfin
+          : url is String && url.isNotEmpty
+              ? DeliveryKind.link
+              : r.members.any((m) => m.host)
+                  ? DeliveryKind.hostFile
+                  : DeliveryKind.serverFile;
+  final sourceId = switch (kind) {
+    DeliveryKind.memberRelay => relay!.source,
+    DeliveryKind.hostFile => r.members.firstWhere((m) => m.host).id,
+    _ => '',
+  };
+  final source = r.members.where((m) => m.id == sourceId).firstOrNull;
+  var via = 0, direct = 0;
+  for (final m in r.members) {
+    if (!isPresent(m) || m.id == sourceId) continue;
+    switch (routeOf(m, kind, sourceId, ref, r.relay)) {
+      case DeliveryRoute.server:
+        via++;
+      case DeliveryRoute.direct:
+        direct++;
+      default:
+        break;
+    }
+  }
+  // A Jellyfin item that everyone streams with their own account: the
+  // relay stands by, nothing goes through it.
+  if (kind == DeliveryKind.memberRelay && ref != null && via == 0 && source != null) {
+    return Delivery(kind: DeliveryKind.jellyfin, direct: direct);
+  }
+  final state = relay == null
+      ? SourceState.ok
+      : kind == DeliveryKind.memberRelay && source == null
+          ? SourceState.left
+          : kind == DeliveryKind.memberRelay && (relay.sourceGone || source?.presence == Presence.gone)
+              ? SourceState.gone
+          : !relay.live
+              ? SourceState.waiting
+              : relay.slow
+                  ? SourceState.slow
+                  : SourceState.ok;
+  return Delivery(
+    kind: kind,
+    sourceId: sourceId,
+    sourceName: source?.name ?? names?[sourceId] ?? 'The member passing it on',
+    sourceIsSelf: sourceId.isNotEmpty && sourceId == selfId,
+    state: state,
+    goneSince: state == SourceState.gone ? relay?.sourceGoneSince ?? source?.goneSince : null,
+    at: now ?? DateTime.now().toUtc(),
+    rate: relay?.rate ?? 0,
+    need: relay?.need ?? 0,
+    viaServer: via,
+    direct: direct,
+  );
+}
+
+/// How [m] gets media of [kind] served by [sourceId]. Jellyfin: by its
+/// last `report.jf` for [ref]'s server ([jellyfinRelay]: the server can
+/// relay it); null before it reported.
+DeliveryRoute? routeOf(MemberView m, DeliveryKind kind, String sourceId, JellyfinRef? ref, bool jellyfinRelay) {
+  if (sourceId.isNotEmpty && m.id == sourceId) return DeliveryRoute.source;
+  switch (kind) {
+    case DeliveryKind.link:
+      return DeliveryRoute.direct;
+    case DeliveryKind.hostFile:
+    case DeliveryKind.serverFile:
+    case DeliveryKind.serverFetch:
+      return DeliveryRoute.server;
+    case DeliveryKind.memberRelay:
+    case DeliveryKind.jellyfin:
+      final own = ref == null ? null : m.jf[ref.serverId];
+      if (own == true) return DeliveryRoute.direct;
+      if (kind == DeliveryKind.memberRelay) return DeliveryRoute.server;
+      return own == false && jellyfinRelay ? DeliveryRoute.server : null;
+  }
+}
+
+/// [m]'s route and buffer for [d] (from [deliveryOf] on [r]).
+MemberDelivery memberDeliveryOf(MemberView m, StateBroadcast r, Delivery d) {
+  final counts = countsForReady(m);
+  final need = r.bufferNeed;
+  final ref = refOfStateMedia(r.media);
+  final health = !counts
+      ? null
+      : m.buffered >= need
+          ? BufferHealth.good
+          : r.transport == 'playing' && m.buffered < 1
+              ? BufferHealth.starving
+              : BufferHealth.low;
+  return MemberDelivery(
+    route: m.presence == Presence.away ? null : routeOf(m, d.kind, d.sourceId, ref, r.relay),
+    kind: d.kind,
+    jellyfin: ref != null,
+    rate: m.rate,
+    health: health,
+    buffered: m.buffered,
+  );
+}
+
+/// What the source is told once per media when it is too slow; null
+/// while it keeps up (or this member is not the source).
+String? slowSourceWarning(StateBroadcast r, String selfId) {
+  final rel = r.media?['relay'];
+  if (rel is! Map || selfId.isEmpty) return null;
+  final relay = MediaRelay.fromJson(Map<String, Object?>.from(rel));
+  if (relay.source != selfId || !relay.slow) return null;
+  return 'Your upload (${formatRate(relay.rate)}) is slower than this video needs '
+      '(${formatRate(relay.need)}): the others will pause to buffer now and then.';
+}

apps/desktop/lib/src/session/health.dart

@@ -1,7 +0,0 @@
-enum HealthSeverity { ok, info, warn, error }
-
-class HealthStatus {
-  final HealthSeverity severity;
-  final String message;
-  const HealthStatus(this.severity, this.message);
-}

apps/desktop/lib/src/session/identity.dart

@@ -1,13 +1,83 @@
 import 'dart:async';
 import 'dart:convert';
+import 'dart:math';
 import 'dart:typed_data';
 
 import 'package:flutter/material.dart';
+import 'package:hive_ce/hive.dart';
 import 'package:signals/signals_flutter.dart';
+import 'package:sync_relay_core/core.dart' show validClientId;
 
-import '../../state/connect_prefs.dart';
-import '../../state/session_state.dart';
-import '../../widgets/avatar_pipeline.dart';
+import '../state/connect_prefs.dart';
+import '../state/session_state.dart';
+import '../state/settings.dart' show settingsBoxName;
+import '../widgets/avatar_pipeline.dart';
+
+// Who this app is: to the server (the per-install client id and its
+// rising connection count, [ClientIdentity]) and to people (name, picture
+// and colour, [Profile]).
+
+/// `hello.client` and `hello.seq` (PROTOCOL.md "Presence"): a random id
+/// per install, kept in the settings box (so per data folder, and per
+/// `STARSYNC_PROFILE`), and a number that rises with every connection this
+/// install makes. A server maps the id to one lasting member; the higher
+/// `seq` wins when two windows of the same install connect.
+class ClientIdentity {
+  static const _keyClient = 'clientId';
+  static const _keySeq = 'clientSeq';
+
+  final Box? _box;
+  ClientIdentity._(this._box, this.clientId, this._seq);
+
+  /// The id: 22 characters of base64url (16 random bytes). Private: never
+  /// shown, never logged.
+  final String clientId;
+  int _seq;
+
+  /// The last `seq` handed out.
+  int get seq => _seq;
+
+  /// The stored identity (the settings box, once open); one is made and
+  /// stored on first use. Without the box (tests, no store): [ephemeral].
+  factory ClientIdentity.stored() {
+    final box = Hive.isBoxOpen(settingsBoxName) ? Hive.box(settingsBoxName) : null;
+    if (box == null) return ClientIdentity.ephemeral();
+    var id = box.get(_keyClient);
+    if (id is! String || !validClientId(id)) {
+      id = newClientId();
+      unawaited(_put(box, _keyClient, id));
+    }
+    final seq = box.get(_keySeq);
+    return ClientIdentity._(box, id, seq is int && seq > 0 ? seq : 0);
+  }
+
+  /// A fresh id kept in memory only (each test coordinator is its own
+  /// install).
+  factory ClientIdentity.ephemeral() => ClientIdentity._(null, newClientId(), 0);
+
+  /// The `seq` for the next hello: one higher than any before, stored at
+  /// once.
+  int nextSeq() {
+    _seq++;
+    final box = _box;
+    if (box != null) unawaited(_put(box, _keySeq, _seq));
+    return _seq;
+  }
+
+  static Future<void> _put(Box box, String key, Object value) async {
+    try {
+      await box.put(key, value);
+    } catch (e) {
+      debugPrint('save $key failed: $e');
+    }
+  }
+
+  /// 16 random bytes as 22 characters of base64url.
+  static String newClientId() {
+    final r = Random.secure();
+    return base64Url.encode([for (var i = 0; i < 16; i++) r.nextInt(256)]).replaceAll('=', '');
+  }
+}
 
 /// Colours offered in the profile card; the first is the default.
 const profileColors = <Color>[

apps/desktop/lib/src/session/idle.dart

@@ -1,43 +0,0 @@
-enum IdleEvent { none, warn, unready }
-
-/// Idle auto-unready clock. Idle time counts from the later of the user's
-/// last input and the last moment playback was running: watching is
-/// activity, so a long watch followed by a pause starts a fresh 10 min.
-/// The unready also always trails its warning by the full grace period.
-class IdleTracker {
-  static const warnAfter = Duration(minutes: 8);
-  static const unreadyAfter = Duration(minutes: 10);
-
-  DateTime _lastActive;
-  DateTime? _warnedAt;
-
-  IdleTracker(DateTime now) : _lastActive = now;
-
-  void activity(DateTime now) {
-    _lastActive = now;
-    _warnedAt = null;
-  }
-
-  /// Called once per tick. Warn and unready only matter while self is
-  /// ready; while playing the ready flag gates nothing.
-  IdleEvent tick(DateTime now, {required bool playing, required bool selfReady}) {
-    if (playing) {
-      activity(now);
-      return IdleEvent.none;
-    }
-    if (!selfReady) return IdleEvent.none;
-    final warnedAt = _warnedAt;
-    if (warnedAt != null) {
-      if (now.difference(warnedAt) >= unreadyAfter - warnAfter) {
-        activity(now);
-        return IdleEvent.unready;
-      }
-      return IdleEvent.none;
-    }
-    if (now.difference(_lastActive) >= warnAfter) {
-      _warnedAt = now;
-      return IdleEvent.warn;
-    }
-    return IdleEvent.none;
-  }
-}

apps/desktop/lib/src/session/media_art.dart

@@ -1,16 +1,19 @@
 import 'dart:async';
 import 'dart:io';
+import 'dart:isolate';
 import 'dart:typed_data';
 
 import 'package:flutter/foundation.dart';
+import 'package:image/image.dart' as img;
 import 'package:sync_relay_core/core.dart';
 
 import '../files/name_parser.dart';
 import '../schedule/anilist.dart';
 
 // Art for media this client swapped in (`art`, see PROTOCOL.md "Media
-// art"): Jellyfin images with this install's account, else an AniList
-// title search. Everything here fails quietly to "no art".
+// art"): Jellyfin images with this install's account, a web link's
+// thumbnail, else an AniList title search. Everything here fails quietly
+// to "no art".
 
 /// Poster and banner bytes; either may be null.
 typedef ArtBytes = ({Uint8List? poster, Uint8List? banner});
@@ -51,7 +54,8 @@ Future<ArtBytes> jellyfinArt(JellyfinClient client, String itemId,
 Future<ArtBytes?> aniListArt(AniListClient aniList, String name,
     {Future<Uint8List?> Function(Uri url, Map<String, String> headers, int maxBytes) fetch = fetchImage}) async {
   final series = parseReleaseName(name).series.trim();
-  if (series.isEmpty) return null;
+  // "1", "2026-10-09": nothing a show could be called.
+  if (!RegExp(r'\p{L}', unicode: true).hasMatch(series)) return null;
   final match = await aniList.searchMedia(series);
   if (match == null) return null;
   Future<Uint8List?> get(String? url, int maxBytes) async {
@@ -67,6 +71,31 @@ Future<ArtBytes?> aniListArt(AniListClient aniList, String name,
   return (poster: poster, banner: banner);
 }
 
+/// A web video's thumbnail at [url] as both cover and banner (the same
+/// bytes, so the same hash: what tells clients it is a thumbnail, see
+/// `NowPlaying.thumbnail`); shrunk to a JPEG under the cover cap when
+/// larger; null when it cannot be had.
+Future<ArtBytes?> thumbnailArt(Uri url,
+    {Future<Uint8List?> Function(Uri url, Map<String, String> headers, int maxBytes) fetch = fetchImage}) async {
+  var bytes = await fetch(url, const {}, 8 * 1024 * 1024);
+  if (bytes != null && bytes.length > RelayConstants.maxPosterBytes) bytes = await _shrinkApart(bytes);
+  return bytes == null ? null : (poster: bytes, banner: bytes);
+}
+
+// Its own function, so the isolate's closure holds nothing but [raw].
+Future<Uint8List?> _shrinkApart(Uint8List raw) => Isolate.run<Uint8List?>(() => _shrinkThumbnail(raw));
+
+Uint8List? _shrinkThumbnail(Uint8List raw) {
+  final decoded = img.decodeImage(raw);
+  if (decoded == null) return null;
+  for (final width in const [1280, 960, 640]) {
+    final small = decoded.width > width ? img.copyResize(decoded, width: width, interpolation: img.Interpolation.average) : decoded;
+    final jpg = img.encodeJpg(small, quality: 82);
+    if (jpg.length <= RelayConstants.maxPosterBytes) return jpg;
+  }
+  return null;
+}
+
 /// GET [url]: the bytes when 200, at most [maxBytes] and a known image
 /// type (see `avatarImageType`); else null.
 Future<Uint8List?> fetchImage(Uri url, Map<String, String> headers, int maxBytes) async {

apps/desktop/lib/src/session/notice_prefs.dart

@@ -0,0 +1,29 @@
+// The user's notification choices (Settings → Notifications & sounds), as
+// the Notifier's policy reads them. Pure Dart; [AppSettings] stores them.
+
+/// When chat messages pop up as toasts (they always reach the chat).
+enum ChatPopups {
+  all('All'),
+  paused('Only when paused'),
+  off('Off');
+
+  final String label;
+  const ChatPopups(this.label);
+
+  /// Whether a chat message pops up now ([playing]: the video plays).
+  bool shows({required bool playing}) => switch (this) {
+        ChatPopups.all => true,
+        ChatPopups.paused => !playing,
+        ChatPopups.off => false,
+      };
+}
+
+/// What the user picked: chat pop-ups, and whether joins and leaves also
+/// reach them while they sit out or the window is in the background
+/// ([people]; off by default: then only chat, nudges, "starting now" and
+/// Up next do).
+class NotifyPrefs {
+  final ChatPopups chat;
+  final bool people;
+  const NotifyPrefs({this.chat = ChatPopups.all, this.people = false});
+}

apps/desktop/lib/src/session/notifier.dart

@@ -0,0 +1,432 @@
+import 'dart:async';
+
+import 'package:signals/signals_core.dart';
+import 'package:sync_relay_core/core.dart' show FeedMessage, Presence;
+
+import '../platform/ports/system_notifications.dart';
+import '../platform/ports/window_activity.dart';
+import '../sfx/sfx.dart';
+import 'app_events.dart';
+import 'notice_prefs.dart';
+
+export 'app_events.dart';
+export 'notice_prefs.dart';
+
+class ToastItem {
+  final int id;
+  final String text;
+  final DateTime at;
+  /// The member a feed or chat toast is about (their name, as the feed
+  /// carries it; [text] starts with it); null for the app's own toasts.
+  final String? actor;
+  /// [actor]'s member id (feed and chat toasts); '' when unknown.
+  final String actorId;
+  /// A chat message: a click opens the chat.
+  final bool chat;
+  /// A picture hash to show (an Up next item's), '' when none.
+  final String thumb;
+  const ToastItem(
+      {required this.id,
+      required this.text,
+      required this.at,
+      this.actor,
+      this.actorId = '',
+      this.chat = false,
+      this.thumb = ''});
+}
+
+/// What a notice is about; the policy filters by it ([noticeFor]).
+enum NoticeCategory {
+  /// Chat messages.
+  chat,
+
+  /// Someone poked this member.
+  nudge,
+
+  /// The media starts playing for the first time ("starting now").
+  start,
+
+  /// Up next and the video changing (adds, skips, swaps).
+  upNext,
+
+  /// Joins, leaves, lost signal and returns.
+  people,
+
+  /// The rest of what the party does (ready, seeks, pauses, someone sat
+  /// out, renames): the activity log and a few sounds.
+  party,
+
+  /// Something keeps the watch from going smoothly (someone cannot play
+  /// it, the source dropped, the server could not fetch it).
+  problem,
+
+  /// About this member itself (sat out, auto sit-out, the relay it
+  /// serves, its connection, another window took over).
+  self,
+
+  /// The app's own notices (copied, shaders, update, errors): never
+  /// filtered.
+  app;
+
+  /// What reaches you while you sit out or the window is in the
+  /// background (D1): chat, nudges, "starting now" and Up next, plus joins
+  /// and leaves when [NotifyPrefs.people] is on.
+  bool reachesAway(NotifyPrefs prefs) => switch (this) {
+        chat || nudge || start || upNext || self || app => true,
+        people => prefs.people,
+        party || problem => false,
+      };
+
+  /// Social: nothing of it plays or pops up while you watch alone (D9).
+  bool get social => this == chat || this == start || this == people || this == party;
+
+  /// May go out as a system notification while the window is in the
+  /// background.
+  bool get system => this == chat || this == nudge || this == start || this == upNext || this == people;
+}
+
+/// The session as the policy sees it.
+typedef NoticeSession = ({Presence? self, bool alone, bool playing});
+
+/// Where the user stands when a notice comes: their presence ([self],
+/// null outside a session), whether anyone else is there ([alone]), the
+/// window ([window]), whether the video plays ([playing]) and their
+/// choices ([prefs]). A replayed feed line says so itself.
+class NoticeContext {
+  final Presence? self;
+  final bool alone;
+  final WindowActivity window;
+  final bool playing;
+  final NotifyPrefs prefs;
+  const NoticeContext({
+    this.self,
+    this.alone = false,
+    this.window = WindowActivity.focused,
+    this.playing = false,
+    this.prefs = const NotifyPrefs(),
+  });
+
+  bool get away => self == Presence.away;
+}
+
+/// A notification outside the window ([SystemNotifications]).
+class SystemNote {
+  final String title;
+  final String body;
+  final String tag;
+  /// [payloadChat]: a click opens the chat.
+  final String payload;
+  const SystemNote({required this.title, required this.body, this.tag = '', this.payload = ''});
+
+  static const payloadChat = 'chat';
+}
+
+/// What one [AppEvent] does: a toast ([toast], about [actor]), a sound,
+/// the window asking for attention, a system notification, an
+/// activity-log line.
+class Notice {
+  final NoticeCategory category;
+  final String? toast;
+  final String? actor;
+  /// The toast is a chat message (a click opens the chat).
+  final bool chat;
+  /// A picture hash for the toast (an Up next item's).
+  final String thumb;
+  final SfxCue? sound;
+  final bool attention;
+  final SystemNote? system;
+  /// The feed line it goes into the activity log as.
+  final FeedMessage? log;
+  const Notice({
+    this.category = NoticeCategory.app,
+    this.toast,
+    this.actor,
+    this.chat = false,
+    this.thumb = '',
+    this.sound,
+    this.attention = false,
+    this.system,
+    this.log,
+  });
+
+  static const none = Notice();
+
+  Notice _with({bool toast = true, bool sound = true, SystemNote? system}) => Notice(
+        category: category,
+        toast: toast ? this.toast : null,
+        actor: toast ? actor : null,
+        chat: toast && chat,
+        thumb: toast ? thumb : '',
+        sound: sound ? this.sound : null,
+        attention: attention,
+        system: system,
+        log: log,
+      );
+}
+
+String _title(String t) => t.isEmpty ? 'the video' : t;
+
+/// The event alone: its category, toast, sound and log line.
+Notice _plain(AppEvent e) => switch (e) {
+      // The feed: everything is logged.
+      MemberJoined(:final feed) => Notice(
+          category: NoticeCategory.people,
+          log: feed,
+          toast: '${feed.actor} joined',
+          actor: feed.actor,
+          sound: const SfxCue(SfxKind.join)),
+      MemberLeft(:final feed) => Notice(
+          category: NoticeCategory.people,
+          log: feed,
+          toast: '${feed.actor} left',
+          actor: feed.actor,
+          sound: const SfxCue(SfxKind.leave)),
+      // After the server's delayed `gone` line (a quick reconnect says
+      // nothing), and back after it.
+      MemberGone(:final feed) => Notice(
+          category: NoticeCategory.people, log: feed, toast: '${feed.actor} lost connection', actor: feed.actor),
+      MemberReturned(:final feed) =>
+        Notice(category: NoticeCategory.people, log: feed, toast: '${feed.actor} is back', actor: feed.actor),
+      MediaSwapped(:final feed) => Notice(
+          category: NoticeCategory.upNext,
+          log: feed,
+          toast: '${feed.actor} changed media',
+          actor: feed.actor,
+          sound: const SfxCue(SfxKind.swap)),
+      QueueAdded(:final feed, :final thumb) => Notice(
+          category: NoticeCategory.upNext,
+          log: feed,
+          toast: '${feed.actor} added ${_title(feed.target ?? '')} to Up next',
+          actor: feed.actor,
+          thumb: thumb),
+      QueueSkipped(:final feed) => Notice(
+          category: NoticeCategory.upNext,
+          log: feed,
+          toast: 'Skipped ${feed.target ?? 'an item'}${feed.reason.isEmpty ? '' : ': ${feed.reason}'}'),
+      QueueRemoved(:final feed) => Notice(category: NoticeCategory.upNext, log: feed),
+      ChatPosted(:final feed) => Notice(
+          category: NoticeCategory.chat,
+          log: feed,
+          toast: '${feed.actor}: ${feed.reason}',
+          actor: feed.actor,
+          chat: true,
+          sound: const SfxCue(SfxKind.chat)),
+      MemberSatOut(:final feed, atYou: true) => Notice(
+          category: NoticeCategory.self,
+          log: feed,
+          toast: '${feed.actor} sat you out',
+          actor: feed.actor,
+          sound: const SfxCue(SfxKind.kick)),
+      MemberSatOut(:final feed, autoSelf: true) => Notice(
+          category: NoticeCategory.self,
+          log: feed,
+          toast: 'You sit out (${feed.reason == 'minimised' ? 'minimised' : 'idle'}); you are back as soon as you return',
+          sound: const SfxCue(SfxKind.warn)),
+      ReadyChanged(:final feed, ready: true, :final readyIndex) =>
+        Notice(category: NoticeCategory.party, log: feed, sound: SfxCue(SfxKind.ready, readyIndex: readyIndex)),
+      ReadyChanged(:final feed, ready: false) =>
+        Notice(category: NoticeCategory.party, log: feed, sound: const SfxCue(SfxKind.unready)),
+      ForcedReady(:final feed, ready: true) =>
+        Notice(category: NoticeCategory.party, log: feed, sound: const SfxCue(SfxKind.forceReady)),
+      FetchFailed(:final feed) => Notice(category: NoticeCategory.problem, log: feed),
+      FeedEvent(:final feed) => Notice(category: NoticeCategory.party, log: feed),
+      // The session.
+      Nudged(:final name) => Notice(
+          category: NoticeCategory.nudge,
+          toast: '${name.isEmpty ? 'Someone' : name} nudged you',
+          actor: name.isEmpty ? null : name,
+          sound: const SfxCue(SfxKind.nudge),
+          attention: true),
+      PlaybackStarted(:final title) =>
+        Notice(category: NoticeCategory.start, toast: title.isEmpty ? 'Starting now' : 'Starting now: $title'),
+      MemberCantPlay(:final name, :final error) =>
+        Notice(category: NoticeCategory.problem, toast: "$name can't play this: $error", actor: name),
+      RelaySourceDropped(:final name, :final left) => Notice(
+          category: NoticeCategory.problem,
+          toast: left
+              ? '$name left: playing what the server has'
+              : "$name's connection dropped: playing what the server has",
+          actor: name),
+      SlowSource(:final text) => Notice(category: NoticeCategory.self, toast: text),
+      RelayStarted() => const Notice(
+          category: NoticeCategory.self,
+          toast: 'Passing the video on through the server. Keep the app open while it plays.'),
+      RelayFailed(:final error) => Notice(category: NoticeCategory.self, toast: 'Cannot pass the video on: $error'),
+      ConnectionLost() => const Notice(category: NoticeCategory.self, sound: SfxCue(SfxKind.lost)),
+      ConnectionBack() => const Notice(category: NoticeCategory.self, sound: SfxCue(SfxKind.back)),
+      ServerRestarted() =>
+        const Notice(category: NoticeCategory.self, toast: 'The server restarted; you are back in'),
+      Replaced() => const Notice(category: NoticeCategory.self, toast: 'Starsync was opened in another window'),
+      ServerRefused(:final text) => Notice(category: NoticeCategory.self, toast: text),
+      JellyfinProgressFailed(:final signInExpired) =>
+        Notice(toast: 'Jellyfin progress not saved: ${signInExpired ? 'sign-in expired' : 'server unreachable'}'),
+      // The app.
+      ShaderMessage(:final text) => Notice(toast: text),
+      AddedToUpNext(:final title) => Notice(toast: 'Added $title to Up next'),
+      ActionFailed(:final text) => Notice(toast: text),
+      ScheduleResult(:final text) => Notice(toast: text),
+      ProblemMarked(:final inSession) =>
+        Notice(toast: inSession ? 'Marked in the session log' : "Marked in this app's log"),
+      Copied(:final text) => Notice(toast: text),
+      CopyFailed() => const Notice(toast: "Couldn't copy"),
+      // The update band shows it (D8: a clear prompt, never over playback).
+      UpdateAvailable() => Notice.none,
+    };
+
+/// The policy: what [e] does for a user in [c].
+/// - Lines a reconnect replayed (`welcome.feed`): the activity log only.
+/// - Your own joins, leaves, swaps and Up next adds: logged, no pop-up or
+///   sound (the app already said so); your own chat pops up, silently.
+/// - Alone (D9): no social sounds or pop-ups (nobody is there); the app's
+///   notices, problems and your own still show.
+/// - Sitting out (D1): only chat, nudges, "starting now", Up next, your
+///   own and the app's, plus joins and leaves when chosen
+///   ([NotifyPrefs.people]); the rest is logged only.
+/// - "Starting now" pops up only while you sit out or the window is in
+///   the background (otherwise you see it start).
+/// - Chat pop-ups follow [NotifyPrefs.chat]; the chat sound has its own
+///   switch (Settings → Sounds).
+/// - The window in the background: what reaches you there also goes out
+///   as a system notification (chat, nudges, "starting now", Up next;
+///   joins and leaves when chosen).
+Notice noticeFor(AppEvent e, [NoticeContext c = const NoticeContext()]) {
+  if (e is FeedEvent && e.feed.replayed) return Notice(category: _plain(e).category, log: e.feed);
+  final n = _plain(e);
+  final cat = n.category;
+  final own = e is FeedEvent && e.own;
+  var toast = n.toast != null;
+  var sound = n.sound != null;
+  if (own && (cat == NoticeCategory.people || cat == NoticeCategory.upNext)) {
+    toast = false;
+    sound = false;
+  }
+  if (own && cat == NoticeCategory.chat) sound = false;
+  if (c.alone && cat.social) {
+    toast = false;
+    sound = false;
+  }
+  if (c.away && !cat.reachesAway(c.prefs)) {
+    toast = false;
+    sound = false;
+  }
+  if (cat == NoticeCategory.start && !c.away && !c.window.background) toast = false;
+  if (cat == NoticeCategory.chat && !c.prefs.chat.shows(playing: c.playing)) toast = false;
+  SystemNote? system;
+  if (toast && !own && c.window.background && cat.system && cat.reachesAway(c.prefs)) {
+    final actor = n.actor;
+    final text = n.toast!;
+    final body = actor != null && text.startsWith(actor) ? text.substring(actor.length).replaceFirst(RegExp(r'^:? '), '') : text;
+    system = SystemNote(
+      title: actor ?? 'Starsync',
+      body: actor == null ? text : body,
+      tag: cat == NoticeCategory.chat ? '' : cat.name,
+      payload: cat == NoticeCategory.chat ? SystemNote.payloadChat : '',
+    );
+  }
+  return n._with(toast: toast, sound: sound, system: system);
+}
+
+/// The one way news reaches the user: [notify] turns an [AppEvent] into
+/// toasts ([toasts], each dropped after [toastLife] by the Notifier's
+/// own timer), sounds, an attention request, a system notification and
+/// the activity log ([feedLog]) per [noticeFor], in the context the
+/// session ([session]), the window ([window]) and the user's choices
+/// ([prefs]) give.
+class Notifier {
+  final SfxService sfx;
+  final Future<void> Function() attention;
+  final SystemNotifications system;
+  /// Brings the window up (a click on a system notification).
+  final Future<void> Function() focusWindow;
+  final Duration toastLife;
+  /// The session's part of the context; set by the coordinator.
+  NoticeSession Function() session = () => (self: null, alone: false, playing: false);
+  NotifyPrefs Function() prefs;
+  /// The window's activity ([ShellPort.watchActivity], wired in `main`).
+  WindowActivity window = WindowActivity.focused;
+
+  Notifier({
+    this.sfx = const NoopSfxService(),
+    Future<void> Function()? attention,
+    this.system = const NoSystemNotifications(),
+    Future<void> Function()? focusWindow,
+    this.toastLife = const Duration(seconds: 5),
+    NotifyPrefs Function()? prefs,
+  })  : attention = attention ?? _nothing,
+        focusWindow = focusWindow ?? _nothing,
+        prefs = prefs ?? _defaultPrefs {
+    system.onClick = _clicked;
+  }
+
+  static Future<void> _nothing() async {}
+  static NotifyPrefs _defaultPrefs() => const NotifyPrefs();
+
+  /// Toasts on screen (the shell shows them).
+  final toasts = signal<List<ToastItem>>([]);
+  /// The activity log: the last 100 feed lines.
+  final feedLog = signal<List<FeedMessage>>([]);
+  /// Bumped when a click on a chat notification asks for the chat (the
+  /// shell opens it).
+  final chatRequests = signal(0);
+  int _toastId = 0;
+  final _timers = <int, Timer>{};
+
+  NoticeContext get context {
+    final s = session();
+    return NoticeContext(self: s.self, alone: s.alone, window: window, playing: s.playing, prefs: prefs());
+  }
+
+  void notify(AppEvent e) {
+    final n = noticeFor(e, context);
+    final log = n.log;
+    if (log != null) {
+      final all = [...feedLog.peek(), log];
+      feedLog.value = all.length > 100 ? all.sublist(all.length - 100) : all;
+    }
+    final text = n.toast;
+    if (text != null) {
+      final id = ++_toastId;
+      toasts.value = [
+        ...toasts.peek(),
+        ToastItem(
+            id: id,
+            text: text,
+            at: DateTime.now().toUtc(),
+            actor: n.actor,
+            actorId: n.actor == null ? '' : n.log?.actorId ?? '',
+            chat: n.chat,
+            thumb: n.thumb),
+      ];
+      _timers[id] = Timer(toastLife, () => dismiss(id));
+    }
+    final sound = n.sound;
+    if (sound != null) unawaited(sfx.play(sound));
+    if (n.attention) unawaited(attention());
+    final note = n.system;
+    if (note != null) {
+      unawaited(system.show(title: note.title, body: note.body, tag: note.tag, payload: note.payload));
+    }
+  }
+
+  void _clicked(String payload) {
+    unawaited(focusWindow());
+    if (payload == SystemNote.payloadChat) chatRequests.value++;
+  }
+
+  /// Takes toast [id] off the screen (its time is up, or it was clicked).
+  void dismiss(int id) {
+    _timers.remove(id)?.cancel();
+    final now = toasts.peek();
+    if (now.any((t) => t.id == id)) toasts.value = [for (final t in now) if (t.id != id) t];
+  }
+
+  /// A new session: no toasts, an empty log.
+  void clear() {
+    for (final t in _timers.values) {
+      t.cancel();
+    }
+    _timers.clear();
+    feedLog.value = [];
+    toasts.value = [];
+  }
+}

apps/desktop/lib/src/session/now_playing.dart

@@ -9,7 +9,11 @@ class NowPlaying {
   /// Portrait cover (2:3) and wide banner; '' when none.
   final String posterHash;
   final String bannerHash;
-  const NowPlaying({required this.title, this.episode, this.posterHash = '', this.bannerHash = ''});
+  /// A web video: its art is its thumbnail (the same picture as cover and
+  /// banner, or none yet), shown wide, under the video's own name.
+  final bool thumbnail;
+  const NowPlaying(
+      {required this.title, this.episode, this.posterHash = '', this.bannerHash = '', this.thumbnail = false});
 
   @override
   bool operator ==(Object other) =>
@@ -17,8 +21,9 @@ class NowPlaying {
       other.title == title &&
       other.episode == episode &&
       other.posterHash == posterHash &&
-      other.bannerHash == bannerHash;
+      other.bannerHash == bannerHash &&
+      other.thumbnail == thumbnail;
 
   @override
-  int get hashCode => Object.hash(title, episode, posterHash, bannerHash);
+  int get hashCode => Object.hash(title, episode, posterHash, bannerHash, thumbnail);
 }