From 00d526740f216422682ffa0b3af7431991f6d907 Mon Sep 17 00:00:00 2001
From: InstaZDLL <github.105mh@8shield.net>
Date: Sun, 25 Oct 2026 02:08:14 +0200
Subject: [PATCH 1/8] docs: RFC-022 proposes playback and web client
 improvements

ReplayGain in the web player through Web Audio, discography sections and appearances on the artist page, an installable client with no service worker, AAC in ADTS, a Subsonic format fallback, and a form body sized for the largest playlist.

Signed-off-by: InstaZDLL <github.105mh@8shield.net>
---
 docs/rfcs/RFC-022-playback-and-web-client.md | 263 +++++++++++++++++++
 1 file changed, 263 insertions(+)
 create mode 100644 docs/rfcs/RFC-022-playback-and-web-client.md

diff --git a/docs/rfcs/RFC-022-playback-and-web-client.md b/docs/rfcs/RFC-022-playback-and-web-client.md
new file mode 100644
index 00000000..37d0f58a
--- /dev/null
+++ b/docs/rfcs/RFC-022-playback-and-web-client.md
@@ -0,0 +1,263 @@
+# RFC-022 — Playback and the web client: loudness, discography, install, AAC
+
+- **Status**: Proposed
+- **Implemented by**: the pull request that carries this RFC. The *Status*
+  field above never flips in this project; this line is the one that says
+  what is running.
+- **Date**: 2026-10-25
+- **Authors**: the WaveFlow project
+- **Depends on**: [RFC-002](RFC-002-waveflow-server-v2.md) (the stream tickets,
+  the frozen Subsonic contract, the one set of domain services)
+
+## Problem
+
+A comparative audit of this server against Navidrome, Meelo, kima-hub and
+Ampache (2026-10-24) listed five gaps in how music reaches a listener. Each
+was checked in the code before this was written, and two of them turned out
+smaller or different from what the audit said:
+
+1. **ReplayGain is read and never applied.** The scanner stores the four
+   ReplayGain values and `SongItem` carries them on `/api/v2`, but the web
+   client's `Song` type does not even declare them, and the player plays every
+   track at the level its master was cut at.
+2. **An artist page is one flat grid.** `album.release_types` is stored, and —
+   contrary to the audit — it *is* on the native wire already: `AlbumItem`
+   serialises it on every album listing. What is missing is a decision about
+   what the values mean, so the page cannot group by them, and nothing lists
+   the albums an artist is credited on without being their album artist.
+3. **The web client cannot be installed.** `webapp/public` has no manifest and
+   no icon a phone accepts, so "Add to home screen" makes a bookmark.
+4. **Transcoding knows two formats, and refuses the rest.** `src/media.rs`
+   encodes MP3 and Opus only. A Subsonic `format=aac` or `format=flac` is
+   answered error 10, where every other server plays something.
+5. **A Subsonic form POST is capped at 64 KiB.** The audit estimated the cap
+   at about 1,600 UUIDs. It is lower, and it depends on the name of the
+   parameter: `songId=<uuid>&` is 44 bytes, so `createPlaylist` stops short of
+   1,490 tracks; `songIdToAdd=<uuid>&` is 49, so `updatePlaylist` stops short
+   of 1,338, less in both cases what the credentials take. A test sending the
+   playlist ceiling of 10,000 in one `updatePlaylist` was answered
+   `Invalid form body` under the old bound. `savePlayQueue` is a
+   different case: it is refused above 400 tracks by `MAX_QUEUE_TRACKS`, a
+   domain bound shared with the native API, long before the body is.
+
+## Decision 1 — ReplayGain in the web player, through Web Audio
+
+The `<audio>` element keeps doing what it does: fetching the stream ticket,
+answering range requests, seeking. When ReplayGain is on, its output is routed
+through `createMediaElementSource` into one `GainNode` and on to the speakers.
+The element is not replaced and its URL does not change, so tickets and range
+requests behave exactly as before.
+
+- **The preference** has three modes: `off`, `track` and `album`, and a preamp
+  from −12 to +12 dB in steps of one, 0 by default. It is per browser, stored
+  in `localStorage` beside the theme, for the reason the volume is: how loud a
+  device should be is not a property of the account.
+- **Which gain.** `album` uses the album gain and the album peak, and falls back
+  to the track's pair when the album gain is missing. `track` uses the track's
+  pair and falls back to the album's when the track gain is missing: an album
+  normalisation is still closer than none. A track with neither plays at unity,
+  **without** the preamp: the preamp raises normalised tracks toward the level
+  of untouched ones, and adding it to an untouched track would undo that.
+- **Clipping.** When the peak paired with the chosen gain is known, the linear
+  gain is capped at `1 / peak`, so a quiet track with a hot peak is raised only
+  as far as it can go without clipping. There is no switch for it: a gain that
+  clips is not a loudness preference. The total is also bounded to
+  [−60, +18] dB, against a tag that is simply wrong.
+- **Off by default, and opt-in.** Routing an element through an `AudioContext`
+  is not free on every browser. Some mobile browsers suspend the context with
+  the page, which stops playback on the lock screen — the very case an
+  installed client (decision 4) makes common. So the graph is built only when the listener turns ReplayGain
+  on, on that gesture or the next play, never on page load. Once built, an
+  element cannot be detached from it; turning ReplayGain off afterwards sets the
+  gain to one, and a reload goes back to the plain element.
+- **Same origin, by construction.** `createMediaElementSource` outputs silence
+  for cross-origin media without CORS. Stream tickets are relative URLs
+  (`/api/v2/stream/{ticket}`), resolved against the page that is playing them,
+  so the media is always same-origin. The player checks it anyway and leaves
+  the gain at one for a URL on another origin, rather than going silent.
+- **A suspended context is resumed** on every play the listener starts, which
+  is always a gesture; the browser refuses a resume outside one.
+
+The gain is computed in `webapp/src/lib/replay-gain.ts`, with no React in it,
+and tested there.
+
+## Decision 2 — what a release type means, decided once, on the server
+
+`AlbumItem` gains **`release_group`**, one of `album`, `ep`, `single`, `live`,
+`compilation`. It is derived where the row is read, from `release_types` and
+`is_compilation`, by one function in `src/services/`. The web client, the
+desktop application and anything else group by that field rather than each
+reinterpreting MusicBrainz's vocabulary in its own way.
+
+`release_types` holds whatever the files carried: MusicBrainz's primary type
+(`album`, `single`, `ep`, `broadcast`, `other`) and any secondary types
+(`compilation`, `live`, `soundtrack`, `remix`, `dj-mix`, `demo` and the rest),
+joined with `;` by the scanner. Picard's ID3v2.3 output joins them with `/`
+instead (`album/live`). Each value is therefore split on `;`, `/` and `,`,
+trimmed and compared without case. The first rule that matches wins:
+
+| Rule | Group |
+|---|---|
+| `is_compilation`, or a `compilation` type | `compilation` |
+| a `live` type | `live` |
+| an `ep` type | `ep` |
+| a `single` type | `single` |
+| anything else, or nothing at all | `album` |
+
+- **Secondary before primary.** MusicBrainz files a live EP and a compilation
+  album under its secondary type on its own artist pages, and so does this.
+- **Unknown means album.** Most libraries carry no release type at all; they
+  keep the single "Albums" section they had. `broadcast`, `other`, `soundtrack`,
+  `remix` and the rest fall to their primary type, or to `album`.
+- **The Subsonic wire does not change.** Nodes are built field by field, so
+  `releaseTypes` stays what the file said and the new field is native only.
+
+## Decision 3 — "Appears on"
+
+`GET /api/v2/artists/{id}` gains **`appears_on`**: the albums of which at least
+one available track credits the artist in its `artist` role
+(`track_participant`), and on which the artist is **not** an album artist
+(`album_participant`, role `albumartist`). In the order the page's own albums
+use, year then title.
+
+- **The `artist` role only.** A composer, a producer or a performer credit is a
+  different relation; a page listing every record someone engineered would be
+  a credits page, not a discography.
+- **Built on `album_select!`**, so the first bind is the user and every album
+  passes through `library_member`. The artist is resolved through the same
+  `artist_summary` lookup first, so an artist in another library answers 404
+  and its appearances are never computed.
+- **The native page only.** It is filled by `artist_page`, as the enrichment is.
+  The Subsonic `getArtist` path does not compute it: it has nowhere to put it,
+  and a client syncing every artist would pay for a query it never reads.
+  `GET /api/v2/artists/{id}/albums` stays the album-artist list it is.
+
+The artist page then shows, in this order and each only when it holds
+something: Albums, EPs, Singles, Live, Compilations, Appears on.
+
+## Decision 4 — an installable client, with no service worker
+
+- **A manifest** at `/manifest.webmanifest`: name, `start_url` and `scope` at
+  `/`, `display: standalone`, the application's background and theme colours,
+  and PNG icons at 192 and 512 pixels, the second also as a **maskable** icon
+  whose mark sits inside the safe zone. An `apple-touch-icon` at 180 pixels
+  covers iOS, which reads that tag rather than the manifest's icons.
+- **No service worker.** Chromium no longer requires one to install, and iOS
+  never has. A worker is the one piece of a PWA that can serve stale or
+  private data: a cached shell pointing at hashed assets a deploy removed, or
+  a response that should never have outlived the session. Not having one is
+  the strongest form of the rule that API responses, stream tickets and
+  authenticated data are never cached. Offline playback is out of scope; if it
+  comes, it comes with its own RFC.
+- **Served as itself, never as the shell.** `rust_embed` types the file
+  `application/manifest+json`. The router fallback answers the client shell
+  for any path it does not know, so a build without the manifest would hand a
+  browser HTML where it expects JSON. The manifest and the icons are therefore
+  **asset-only paths**: present, they are served with their type; absent, they
+  answer a JSON 404, never `text/html` — the treatment `favicon.ico` already
+  has, for the same reason.
+
+## Decision 5 — AAC, in ADTS
+
+The third output format is **AAC-LC in an ADTS stream** (`-c:a aac -f adts`,
+`audio/aac`, `.aac`), at 192 kbit/s unless a bitrate is asked for.
+
+- **ADTS, not fragmented MP4.** Every transcode is written to a pipe as it is
+  produced. ADTS is a sequence of self-describing frames, so it streams from
+  the first byte, and a cached file seeks by byte range the way a constant
+  rate MP3 does. A fragmented MP4 written to a pipe has an empty `moov` and no
+  index, so its duration is unknown and seeking means walking every fragment;
+  a regular MP4 needs its index at the front, which FFmpeg can only write by
+  rewinding a file it has finished — not a pipe. ADTS is what internet radio
+  has streamed AAC in for twenty years, and Safari, Chrome, Firefox and
+  Android's players all decode it.
+- **FFmpeg's own `aac` encoder.** `libfdk_aac` is better at low rates and is
+  missing from most builds, because its licence is not GPL-compatible. The
+  native encoder is in every FFmpeg, which is what lets AAC be offered
+  unconditionally.
+- **On every surface.** `format=aac` on the native stream routes and on the
+  stream ticket; `aac`, `m4a` and `adts` on Subsonic.
+  `GET /api/v2/transcode/status` gains `formats`, the outputs this server can
+  produce, so a client can offer AAC without guessing from a version number.
+
+## Decision 6 — a format the façade cannot produce falls back
+
+A Subsonic `format` the server does not produce — `flac`, `wav`, `alac`, a
+typo — is treated **as if no format had been named**: the original when
+`maxBitRate` admits it, MP3 at the cap when it does not. The response's
+`Content-Type` names what was actually sent, which is how every Subsonic client
+already learns it.
+
+- **Why the original.** A client asking for `flac` usually streams a FLAC
+  library and wants the file; this is exactly what it gets. A client asking for
+  `flac` over an MP3 gets the MP3, which plays, where an error plays nothing.
+  This is also what Navidrome does with a format it has no transcoding for.
+- **Only Subsonic.** The native API keeps refusing an unknown format with a
+  `400`: its clients are versioned with this server and read `formats` from
+  the status route, and an error is the honest answer to a request this server
+  cannot meet.
+- **The frozen contract.** This changes observable behaviour on `/rest`: a
+  request answered error 10 now answers audio. No client validated against the
+  contract can depend on that error — it is a refusal to play — and
+  `docs/subsonic-compatibility.md` records the change beside the others.
+
+## Decision 7 — the form body holds the largest playlist
+
+The Subsonic form body is bounded at
+`MAX_PLAYLIST_TRACKS × 64 bytes + 64 KiB`, **705,536 bytes** today. Derived from
+the playlist ceiling rather than written down, like the playlist import route's
+limit and for the same reason: raising the ceiling must not quietly start
+refusing the requests it has just permitted.
+
+- **64 bytes per identifier** covers the longest pair the façade accepts,
+  `songIdToAdd=<uuid>&` at 49, and every shorter one. UUIDs need no percent
+  encoding.
+- **64 KiB of envelope**, the whole of the old limit, for the credentials, the
+  playlist's name and comment and whatever else a client sends beside them.
+- **Still bounded.** A request is read into memory at most once, up to that
+  size; one byte over is refused with error 10 as before. The writer gate is
+  bounded by the domain's own ceilings, which this does not move.
+
+## What does not change
+
+- The stream tickets, the range semantics, the transcode cache and its keys
+  for MP3 and Opus.
+- `savePlayQueue`'s ceiling of 400 tracks (see below), and the native API's
+  16 KiB JSON limit.
+- Every Subsonic response for a request that worked before.
+
+## The order of the work
+
+One pull request, holding this RFC and all seven decisions, with tests for
+each:
+
+- the gain computation and the preference parsing in `webapp/src/lib/`, and the
+  discography grouping beside them;
+- the release-group rules, one case per row of the table and the separators;
+- "Appears on", including an album on which the artist is album artist and also
+  credited on a track, which must not appear, and an outsider who gets 404;
+- the manifest's type, and its absence answering JSON rather than the shell;
+- an AAC transcode identified by `ffprobe` as ADTS AAC, cached and then served
+  by range;
+- `format=flac` and `format=aac` on Subsonic;
+- an `updatePlaylist` of exactly `MAX_PLAYLIST_TRACKS` identifiers in one form
+  POST, and a body one byte over the bound refused.
+
+## What is still open
+
+- **`savePlayQueue` above 400 tracks.** `MAX_QUEUE_TRACKS` bounds the native
+  and the Subsonic queue alike, and its comment ties it to the native API's
+  16 KiB JSON limit. Raising it is a domain decision for both surfaces, with
+  its own cost under the writer gate, and is not made here.
+- **A playlist cannot hold a track twice.** Found while writing the test for
+  decision 7: `playlist_track` is keyed on `(playlist_id, track_id)`, so a
+  `createPlaylist` or `updatePlaylist` naming one track twice fails on the
+  insert and answers error 0, an internal error, rather than either keeping
+  the duplicate or refusing it cleanly. The domain's lenient lookup expands
+  duplicates, so the refusal comes from the schema alone. A migration, or a
+  domain decision to refuse duplicates with error 10, is its own change.
+- **ReplayGain on Subsonic `stream`.** Applying gain server-side would mean a
+  transcode for every play; clients apply it themselves from `replayGain`.
+- **Offline playback** and the service worker it would need.
+- **A per-device default for ReplayGain** once the lock-screen behaviour of
+  Web Audio has been measured on real phones rather than inferred.

From 3451f1d4fc600f0582e07ce0c9498c82e60fcdc8 Mon Sep 17 00:00:00 2001
From: InstaZDLL <github.105mh@8shield.net>
Date: Sun, 25 Oct 2026 02:08:21 +0200
Subject: [PATCH 2/8] feat: aac transcodes, a subsonic format fallback, release
 groups and appearances (RFC-022)

AAC-LC is the third transcode, written as ADTS so it streams down a pipe and seeks by range once cached; transcode/status lists the formats. A Subsonic format the server cannot produce is read as no format at all instead of error 10. Albums carry a release_group derived once from release_types and the compilation flag, and the native artist page lists appears_on: albums crediting the artist in the artist role on which they are not album artist. The formPost body is bounded at MAX_PLAYLIST_TRACKS x 64 + 64 KiB, so a playlist at the ceiling fits in one call. The manifest and icons are answered as themselves or a JSON 404, never the client shell.

Signed-off-by: InstaZDLL <github.105mh@8shield.net>
---
 docs/api-v2-guide.md              |  34 +++-
 docs/subsonic-compatibility.md    |  31 +++
 src/api/playback.rs               |   8 +
 src/lib.rs                        |   1 +
 src/media.rs                      |  34 +++-
 src/services/artist_enrichment.rs |   3 +
 src/services/artists.rs           |  40 ++++
 src/services/mod.rs               | 148 +++++++++++++-
 src/subsonic/media.rs             |  24 ++-
 src/subsonic/mod.rs               |  18 +-
 src/webui.rs                      |  19 ++
 tests/media.rs                    | 128 ++++++++++++
 tests/native_api.rs               | 229 ++++++++++++++++++++++
 tests/service.rs                  |  63 ++++++
 tests/subsonic_methods.rs         | 310 ++++++++++++++++++++++++++++++
 15 files changed, 1071 insertions(+), 19 deletions(-)

diff --git a/docs/api-v2-guide.md b/docs/api-v2-guide.md
index d0467e99..81813b53 100644
--- a/docs/api-v2-guide.md
+++ b/docs/api-v2-guide.md
@@ -335,6 +335,21 @@ listing never has to load the tracks to size it, plus `is_compilation`,
 `musicbrainz_id` too. An `AlbumItem` also carries `artists` and `genres`, derived
 from its available tracks.
 
+It carries `release_types` as the files spelled them, and since
+[RFC-022](rfcs/RFC-022-playback-and-web-client.md) a `release_group` derived
+from them: one of `album`, `ep`, `single`, `live` or `compilation`. Group a
+discography by that field rather than by the raw types, whose vocabulary and
+separators vary by tagger. The rule, applied in order: a compilation flag or
+type, then a `live` type, then `ep`, then `single`; anything else, or no type
+at all, is an `album`.
+
+`GET /api/v2/artists/{artist_id}` also carries `appears_on`: the albums of which
+at least one available track credits the artist in its `artist` role, and on
+which the artist is not an album artist — a guest appearance, a split single.
+Credits in other roles (composer, producer, performer) do not count. It is
+present on that route only; `GET /api/v2/artists/{artist_id}/albums` stays the
+album-artist list.
+
 Those two are release and artist identifiers, not the recording identifier a
 `SongItem` carries under the same name, and neither is read from a single file.
 Tracks of one album routinely disagree — a library assembled over years holds
@@ -451,8 +466,13 @@ curl "https://music.example.com/api/v2/tracks/TRACK_UUID/stream?format=opus&bitr
   --output track.ogg
 ```
 
-Valid formats are `raw`, `mp3` and `opus`. Byte ranges apply to originals and
-completed cached transcodes. A live transcode uses temporal `offset_ms` and a
+Valid formats are `raw`, `mp3`, `opus` and `aac`. `aac` is AAC-LC in an ADTS
+stream (`audio/aac`), added by
+[RFC-022](rfcs/RFC-022-playback-and-web-client.md); a client that must work
+against an older server reads `formats` from `GET /api/v2/transcode/status`
+before offering it. Any other value is refused with `400`: unlike the Subsonic
+façade, this API does not fall back to a format nobody asked for. Byte ranges
+apply to originals and completed cached transcodes. A live transcode uses temporal `offset_ms` and a
 chunked response; it does not implement arbitrary output-byte ranges.
 
 Seeking a live transcode through `offset_ms` abandons the stream that was
@@ -611,10 +631,16 @@ See [RFC-007](rfcs/RFC-007-library-event-stream.md) for the reasoning.
 Transcoding is bounded twice: once for the whole server and once per account.
 `GET /api/v2/transcode/status` reports both ceilings alongside `active`, so a
 client can size its own concurrency before asking rather than discovering the
-limit by being refused:
+limit by being refused. It also lists the `formats` a transcode can produce:
 
 ```json
-{ "available": true, "active": 1, "global_limit": 4, "per_user_limit": 2 }
+{
+  "available": true,
+  "active": 1,
+  "global_limit": 4,
+  "per_user_limit": 2,
+  "formats": ["mp3", "opus", "aac"]
+}
 ```
 
 Over either ceiling the stream route answers `429` with `Retry-After`.
diff --git a/docs/subsonic-compatibility.md b/docs/subsonic-compatibility.md
index f0342833..7017b744 100644
--- a/docs/subsonic-compatibility.md
+++ b/docs/subsonic-compatibility.md
@@ -202,6 +202,37 @@ in JSON and in XML.
 
 Browser-hosted clients need their exact origins in the comma-separated `WAVEFLOW_ALLOWED_ORIGINS` setting. The server permits GET, form POST and OPTIONS from those origins and exposes the byte-range response headers used by web audio players. Wildcard origins are deliberately unsupported.
 
+## Deviation for RFC-022: a format the server cannot produce falls back, and AAC
+
+Two changes to `stream` land with
+[RFC-022](rfcs/RFC-022-playback-and-web-client.md), after the 2026-09-16
+replay, and no client has been replayed against them yet.
+
+- **`format=aac` is produced** — also spelled `m4a` or `adts`, in any case — as
+  AAC-LC in an ADTS stream, `Content-Type: audio/aac`, 192 kbit/s unless
+  `maxBitRate` names a rate. ADTS rather than an MP4 because a transcode is
+  written down a pipe as it is made: ADTS streams from its first byte and a
+  cached file seeks by byte range, while a regular MP4 cannot be written to a
+  pipe at all and a fragmented one has no index to seek by.
+- **A format the server cannot produce is read as no format at all**, where it
+  used to be answered error 10 (`Unsupported format`): `flac`, `wav`, `alac`
+  or a typo now get the original while `maxBitRate` admits it, and MP3 at the
+  cap when it does not — the same answers a request naming no format gets. The
+  `Content-Type` names what was sent. A client asking for FLAC over a FLAC
+  library gets the file it wanted; one asking for FLAC over an MP3 gets an MP3
+  that plays, which is what Navidrome does too.
+
+This changes observable behaviour under a frozen contract, and the reason it is
+taken anyway is that the old answer was a refusal to play: no validated client
+depends on error 10 here, because a client receiving it plays nothing. A request
+that worked before is answered exactly as it was.
+
+The same RFC raises the `formPost` body bound from 64 KiB to
+`MAX_PLAYLIST_TRACKS × 64 + 64 KiB` (705,536 bytes), so a playlist of the ten
+thousand tracks the domain allows can be written in one `updatePlaylist` or
+`createPlaylist`. Only requests that used to be refused with
+`Invalid form body` are affected.
+
 ## The replay this alignment required
 
 These rows had all been re-run on 2026-08-19, against a catalogue whose artist
diff --git a/src/api/playback.rs b/src/api/playback.rs
index 8c7c2e03..2d8c36d5 100644
--- a/src/api/playback.rs
+++ b/src/api/playback.rs
@@ -45,6 +45,10 @@ pub struct TranscodeStatusResponse {
     /// concurrency except by being refused.
     pub global_limit: usize,
     pub per_user_limit: usize,
+    /// The formats a transcode can produce, as `format=` spells them on the
+    /// stream routes: `mp3`, `opus` and, since RFC-022, `aac`. `raw` is
+    /// always accepted and is not a transcode, so it is not listed.
+    pub formats: Vec<&'static str>,
 }
 
 #[utoipa::path(post, path = "/api/v2/scrobbles", tag = "user-data", request_body = ScrobbleRequest, responses((status = 204), (status = 401, body = ErrorResponse), (status = 404, body = ErrorResponse), (status = 422, body = ErrorResponse)))]
@@ -158,5 +162,9 @@ pub async fn transcode_status(
         active: state.media.active_transcodes(),
         global_limit,
         per_user_limit,
+        formats: crate::media::OutputFormat::TRANSCODED
+            .iter()
+            .map(|format| format.name())
+            .collect(),
     }))
 }
diff --git a/src/lib.rs b/src/lib.rs
index f8b35f42..ae50e818 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -273,6 +273,7 @@ fn chunk_body_limit(limits: &config::UploadLimits) -> usize {
         catalog::TrackRecord,
         catalog::LibraryAccess,
         services::AlbumItem,
+        services::ReleaseGroup,
         services::ArtistItem,
         services::GenreItem,
         services::LibraryMember,
diff --git a/src/media.rs b/src/media.rs
index a603f51a..a1fc356f 100644
--- a/src/media.rs
+++ b/src/media.rs
@@ -83,6 +83,27 @@ pub enum OutputFormat {
     Raw,
     Mp3,
     Opus,
+    /// AAC-LC in an ADTS stream (RFC-022 decision 5): self-describing frames
+    /// that stream from the first byte down a pipe and seek by byte range once
+    /// cached. A regular MP4 cannot be written to a pipe, and a fragmented one
+    /// carries no index to seek by.
+    Aac,
+}
+
+impl OutputFormat {
+    /// Every format a transcode can produce, as the native API spells them.
+    /// `GET /api/v2/transcode/status` lists them so a client can offer AAC
+    /// without inferring it from a version number.
+    pub const TRANSCODED: [Self; 3] = [Self::Mp3, Self::Opus, Self::Aac];
+
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Raw => "raw",
+            Self::Mp3 => "mp3",
+            Self::Opus => "opus",
+            Self::Aac => "aac",
+        }
+    }
 }
 
 #[derive(Debug, Deserialize)]
@@ -337,6 +358,12 @@ impl MediaService {
                     "ogg",
                 ]);
             }
+            OutputFormat::Aac => {
+                // FFmpeg's own encoder, which every build has: `libfdk_aac` is
+                // better at low rates and missing from most builds, since its
+                // licence is not GPL-compatible.
+                command.args(["-c:a", "aac", "-b:a", &bitrate_arg, "-f", "adts"]);
+            }
             OutputFormat::Raw => return Err(MediaError::InvalidRequest),
         }
         Ok(command)
@@ -1213,7 +1240,7 @@ pub async fn create_stream_ticket(
     tag = "media",
     params(
         ("ticket" = String, Path),
-        ("format" = Option<String>, Query, description = "raw, mp3 or opus"),
+        ("format" = Option<String>, Query, description = "raw, mp3, opus or aac (ADTS)"),
         ("bitrate" = Option<u32>, Query),
         ("offset_ms" = Option<u64>, Query),
         ("download" = Option<String>, Query, description = "1: the original, as an attachment named after the file (RFC-012)")
@@ -1372,7 +1399,7 @@ const ATTR_CHAR: &percent_encoding::AsciiSet = &percent_encoding::NON_ALPHANUMER
     tag = "media",
     params(
         ("track_id" = Uuid, Path),
-        ("format" = Option<String>, Query, description = "raw, mp3 or opus"),
+        ("format" = Option<String>, Query, description = "raw, mp3, opus or aac (ADTS)"),
         ("bitrate" = Option<u32>, Query),
         ("offset_ms" = Option<u64>, Query)
     ),
@@ -1669,6 +1696,7 @@ fn validate_bitrate(format: OutputFormat, bitrate: Option<u32>) -> Result<u32, M
     let bitrate = bitrate.unwrap_or(match format {
         OutputFormat::Mp3 => 192,
         OutputFormat::Opus => 128,
+        OutputFormat::Aac => 192,
         OutputFormat::Raw => return Err(MediaError::InvalidRequest),
     });
     if !(32..=512).contains(&bitrate) {
@@ -1718,6 +1746,7 @@ fn extension(format: OutputFormat) -> &'static str {
         OutputFormat::Raw => "bin",
         OutputFormat::Mp3 => "mp3",
         OutputFormat::Opus => "opus",
+        OutputFormat::Aac => "aac",
     }
 }
 
@@ -1726,6 +1755,7 @@ fn mime_for_format(format: OutputFormat) -> &'static str {
         OutputFormat::Raw => "application/octet-stream",
         OutputFormat::Mp3 => "audio/mpeg",
         OutputFormat::Opus => "audio/ogg",
+        OutputFormat::Aac => "audio/aac",
     }
 }
 
diff --git a/src/services/artist_enrichment.rs b/src/services/artist_enrichment.rs
index 63cab2f4..12d6a86c 100644
--- a/src/services/artist_enrichment.rs
+++ b/src/services/artist_enrichment.rs
@@ -28,6 +28,9 @@ impl DomainServices {
         artist_id: Uuid,
     ) -> Result<ArtistDetail, ServiceError> {
         let mut detail = self.artist(user_id, artist_id).await?;
+        // After `artist`, whose lookup is the tenancy check: an artist this
+        // account cannot see has answered 404 before anything here runs.
+        detail.appears_on = Some(self.artist_appearances(user_id, artist_id).await?);
         detail.enrichment = Some(
             self.enrichment_of(user_id, artist_id, &detail.artist.name, ARTIST_PAGE_SIMILAR)
                 .await?,
diff --git a/src/services/artists.rs b/src/services/artists.rs
index 97635cb4..2db98628 100644
--- a/src/services/artists.rs
+++ b/src/services/artists.rs
@@ -56,12 +56,52 @@ impl DomainServices {
             artist: summary.artist,
             album_count: summary.album_count,
             albums,
+            appears_on: None,
             enrichment: None,
             banner_hash,
             image_choice,
         })
     }
 
+    /// The albums an artist appears on without being one of their artists
+    /// (RFC-022 decision 3), in the order [`Self::artist`] lists its own.
+    ///
+    /// A credit in the track's `artist` role, on an available track: a
+    /// composer, producer or performer credit is a different relation, and a
+    /// page listing every record someone engineered would be a credits page,
+    /// not a discography. An album the artist is album artist of is never
+    /// listed here, however many of its tracks also name them.
+    ///
+    /// The caller has resolved the artist for this user already, so an artist
+    /// in another library never reaches this query; `album_select!` still
+    /// binds the user first and passes every album through `library_member`.
+    pub(super) async fn artist_appearances(
+        &self,
+        user_id: Uuid,
+        artist_id: Uuid,
+    ) -> Result<Vec<AlbumItem>, ServiceError> {
+        let mut albums = sqlx::query(concat!(
+            album_select!(),
+            " AND al.id IN (SELECT t.album_id FROM track_participant tp \
+                 JOIN track t ON t.id=tp.track_id \
+                 WHERE tp.artist_id=? AND tp.role='artist' \
+                   AND t.is_available=1 AND t.album_id IS NOT NULL) \
+              AND NOT EXISTS (SELECT 1 FROM album_participant ap \
+                 WHERE ap.album_id=al.id AND ap.artist_id=? AND ap.role='albumartist') \
+              ORDER BY al.year NULLS LAST, al.title COLLATE NOCASE, al.id"
+        ))
+        .bind(user_id.to_string())
+        .bind(artist_id.to_string())
+        .bind(artist_id.to_string())
+        .fetch_all(self.db.pool())
+        .await?
+        .into_iter()
+        .map(album_from_row)
+        .collect::<Result<Vec<_>, _>>()?;
+        attach_album_relations(&mut *self.db.pool().acquire().await?, user_id, &mut albums).await?;
+        Ok(albums)
+    }
+
     /// One artist the user can see, or [`ServiceError::NotFound`] — for one
     /// that does not exist and one in a library they are not a member of
     /// alike.
diff --git a/src/services/mod.rs b/src/services/mod.rs
index 6276c40a..6ad4a9e2 100644
--- a/src/services/mod.rs
+++ b/src/services/mod.rs
@@ -273,6 +273,11 @@ pub struct AlbumItem {
     pub original_release_date: Option<String>,
     pub release_date: Option<String>,
     pub release_types: Vec<String>,
+    /// Which section of a discography the album belongs in, decided once here
+    /// from `release_types` and `is_compilation` (RFC-022 decision 2) so no
+    /// client reinterprets MusicBrainz's vocabulary its own way. Native only:
+    /// the Subsonic nodes are built field by field and never read it.
+    pub release_group: ReleaseGroup,
     pub record_labels: Vec<String>,
     /// One entry per disc the album's available tracks name a title for.
     /// Derived like the genres, because an album has as many as it has discs.
@@ -290,6 +295,63 @@ pub struct AlbumItem {
     pub duration_ms: i64,
 }
 
+/// The section of an artist's discography an album is listed under.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, ToSchema)]
+#[serde(rename_all = "lowercase")]
+pub enum ReleaseGroup {
+    Album,
+    Ep,
+    Single,
+    Live,
+    Compilation,
+}
+
+impl ReleaseGroup {
+    /// Classifies an album by the release types its files carry (RFC-022
+    /// decision 2).
+    ///
+    /// The values are MusicBrainz's, as taggers write them: a primary type
+    /// (`album`, `single`, `ep`, `broadcast`, `other`) and any secondary ones
+    /// (`compilation`, `live`, `soundtrack`, …). The scanner joins several
+    /// with `;`, and Picard's ID3v2.3 output joins them with `/` instead, so
+    /// each value is split on both — and on `,` — then compared without case.
+    ///
+    /// Secondary types win over primary ones, as on MusicBrainz's own artist
+    /// pages: a live EP is filed under live, a compilation album under
+    /// compilations. Anything else, or nothing at all, is an album, so a
+    /// library that carries no release type keeps the one section it had.
+    pub fn classify(release_types: &[String], is_compilation: bool) -> Self {
+        let mut compilation = is_compilation;
+        let (mut live, mut ep, mut single) = (false, false, false);
+        for kind in release_types
+            .iter()
+            .flat_map(|value| value.split([';', '/', ',']))
+            .map(str::trim)
+        {
+            if kind.eq_ignore_ascii_case("compilation") {
+                compilation = true;
+            } else if kind.eq_ignore_ascii_case("live") {
+                live = true;
+            } else if kind.eq_ignore_ascii_case("ep") {
+                ep = true;
+            } else if kind.eq_ignore_ascii_case("single") {
+                single = true;
+            }
+        }
+        if compilation {
+            Self::Compilation
+        } else if live {
+            Self::Live
+        } else if ep {
+            Self::Ep
+        } else if single {
+            Self::Single
+        } else {
+            Self::Album
+        }
+    }
+}
+
 #[derive(Debug, Clone, Serialize, ToSchema)]
 pub struct SongItem {
     pub id: Uuid,
@@ -963,6 +1025,15 @@ pub struct ArtistDetail {
     /// should not have to depend on one.
     pub album_count: i64,
     pub albums: Vec<AlbumItem>,
+    /// The albums a track of which credits this artist in its `artist` role,
+    /// while the artist is not one of the album's own artists — "Appears on"
+    /// (RFC-022 decision 3).
+    ///
+    /// Filled by [`DomainServices::artist_page`] alone, like the enrichment:
+    /// the Subsonic `getArtist` path has nowhere to put it, and a client that
+    /// syncs every artist would pay for a query it never reads.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub appears_on: Option<Vec<AlbumItem>>,
     /// What metadata enrichment says about this artist — RFC-011 decision 11.
     ///
     /// Always present on `GET /api/v2/artists/{id}`, whose answer comes from
@@ -1942,7 +2013,13 @@ fn artist_summary_from_row(row: sqlx::sqlite::SqliteRow) -> Result<ArtistSummary
 }
 
 fn album_from_row(row: sqlx::sqlite::SqliteRow) -> Result<AlbumItem, sqlx::Error> {
+    let is_compilation = row.try_get::<i64, _>("is_compilation")? != 0;
+    let release_types = split_tag_values(
+        row.try_get::<Option<String>, _>("release_types")?
+            .as_deref(),
+    );
     Ok(AlbumItem {
+        release_group: ReleaseGroup::classify(&release_types, is_compilation),
         id: parse_uuid(row.try_get("id")?)?,
         library_id: parse_uuid(row.try_get("library_id")?)?,
         title: row.try_get("title")?,
@@ -1953,15 +2030,12 @@ fn album_from_row(row: sqlx::sqlite::SqliteRow) -> Result<AlbumItem, sqlx::Error
             .transpose()?,
         artwork_hash: row.try_get("artwork_hash")?,
         year: row.try_get("year")?,
-        is_compilation: row.try_get::<i64, _>("is_compilation")? != 0,
+        is_compilation,
         sort_name: row.try_get("sort_name")?,
         musicbrainz_id: row.try_get("musicbrainz_id")?,
         original_release_date: row.try_get("original_release_date")?,
         release_date: row.try_get("release_date")?,
-        release_types: split_tag_values(
-            row.try_get::<Option<String>, _>("release_types")?
-                .as_deref(),
-        ),
+        release_types,
         record_labels: split_tag_values(
             row.try_get::<Option<String>, _>("record_labels")?
                 .as_deref(),
@@ -2133,3 +2207,67 @@ fn validate_username(username: &str) -> Result<(), ServiceError> {
 fn parse_uuid(value: String) -> Result<Uuid, sqlx::Error> {
     Uuid::from_str(&value).map_err(|error| sqlx::Error::Decode(Box::new(error)))
 }
+
+#[cfg(test)]
+mod release_group_tests {
+    use super::ReleaseGroup;
+
+    fn classify(types: &[&str], is_compilation: bool) -> ReleaseGroup {
+        let types = types
+            .iter()
+            .map(|kind| (*kind).to_owned())
+            .collect::<Vec<_>>();
+        ReleaseGroup::classify(&types, is_compilation)
+    }
+
+    /// One case per row of the table in RFC-022 decision 2, in its order.
+    #[test]
+    fn each_rule_of_the_table_files_its_own_group() {
+        assert_eq!(classify(&["album"], true), ReleaseGroup::Compilation);
+        assert_eq!(
+            classify(&["album", "compilation"], false),
+            ReleaseGroup::Compilation
+        );
+        assert_eq!(classify(&["album", "live"], false), ReleaseGroup::Live);
+        assert_eq!(classify(&["ep"], false), ReleaseGroup::Ep);
+        assert_eq!(classify(&["single"], false), ReleaseGroup::Single);
+        assert_eq!(classify(&["album"], false), ReleaseGroup::Album);
+    }
+
+    /// The first rule that matches wins: secondary types before primary ones.
+    #[test]
+    fn a_secondary_type_wins_over_the_primary_one() {
+        assert_eq!(classify(&["ep", "live"], false), ReleaseGroup::Live);
+        assert_eq!(
+            classify(&["single", "compilation"], false),
+            ReleaseGroup::Compilation
+        );
+        assert_eq!(classify(&["ep", "live"], true), ReleaseGroup::Compilation);
+    }
+
+    /// What the scanner stores joined with `;`, Picard's ID3v2.3 joins with
+    /// `/`, and some taggers capitalise. All of them read the same.
+    #[test]
+    fn separators_and_case_do_not_change_the_answer() {
+        assert_eq!(classify(&["Album/Live"], false), ReleaseGroup::Live);
+        assert_eq!(classify(&["album; live"], false), ReleaseGroup::Live);
+        assert_eq!(classify(&["EP, Remix"], false), ReleaseGroup::Ep);
+        assert_eq!(classify(&[" Single "], false), ReleaseGroup::Single);
+        // A type is matched whole, never as a substring of a longer one.
+        assert_eq!(classify(&["lives"], false), ReleaseGroup::Album);
+        assert_eq!(classify(&["epic"], false), ReleaseGroup::Album);
+    }
+
+    /// Most libraries carry no release type at all, and keep the one section
+    /// they had; types with no section of their own fall to `album`.
+    #[test]
+    fn unknown_or_missing_types_are_albums() {
+        assert_eq!(classify(&[], false), ReleaseGroup::Album);
+        assert_eq!(classify(&["broadcast"], false), ReleaseGroup::Album);
+        assert_eq!(
+            classify(&["album", "soundtrack"], false),
+            ReleaseGroup::Album
+        );
+        assert_eq!(classify(&["other"], false), ReleaseGroup::Album);
+    }
+}
diff --git a/src/subsonic/media.rs b/src/subsonic/media.rs
index fbfd0c13..c4ad479f 100644
--- a/src/subsonic/media.rs
+++ b/src/subsonic/media.rs
@@ -24,15 +24,25 @@ pub(super) async fn media_response(
         .transpose()
         .map_err(|_| invalid("Invalid bitrate"))?
         .filter(|bitrate| *bitrate > 0);
+    // A format this server cannot produce — `flac`, `wav`, `alac`, a typo — is
+    // read as no format at all rather than refused (RFC-022 decision 6): the
+    // original when the cap admits it, MP3 at the cap when it does not. The
+    // `Content-Type` names what was sent, which is how every client learns it.
+    // A refusal plays nothing, and it was the one answer no other server gave.
+    let named =
+        params
+            .first("format")
+            .and_then(|format| match format.to_ascii_lowercase().as_str() {
+                "raw" => Some(OutputFormat::Raw),
+                "mp3" => Some(OutputFormat::Mp3),
+                "opus" | "ogg" => Some(OutputFormat::Opus),
+                "aac" | "m4a" | "adts" => Some(OutputFormat::Aac),
+                _ => None,
+            });
     let format = if download {
         OutputFormat::Raw
-    } else if let Some(format) = params.first("format") {
-        match format {
-            "raw" => OutputFormat::Raw,
-            "mp3" => OutputFormat::Mp3,
-            "opus" | "ogg" => OutputFormat::Opus,
-            _ => return Err(invalid("Unsupported format")),
-        }
+    } else if let Some(format) = named {
+        format
     } else if requested_bitrate.is_some_and(|limit| {
         track
             .bitrate
diff --git a/src/subsonic/mod.rs b/src/subsonic/mod.rs
index 01fd5894..d621d040 100644
--- a/src/subsonic/mod.rs
+++ b/src/subsonic/mod.rs
@@ -55,7 +55,23 @@ const SUBSONIC_VERSION: &str = "1.16.1";
 
 const XMLNS: &str = "http://subsonic.org/restapi";
 
-const MAX_FORM_BYTES: usize = 64 * 1024;
+/// The most a `formPost` body may hold (RFC-022 decision 7).
+///
+/// Sized for the largest request the domain accepts: a playlist of
+/// [`MAX_PLAYLIST_TRACKS`](crate::services::MAX_PLAYLIST_TRACKS) identifiers in
+/// one call. Sixty-four bytes an identifier covers the longest pair the façade
+/// takes, `songIdToAdd=<uuid>&` at forty-nine, and UUIDs never need percent
+/// encoding; the sixty-four kibibytes on top, the whole of the old limit, are
+/// for the credentials, a name, a comment and whatever else rides beside them.
+///
+/// Derived rather than written down, like the playlist import limit: raising
+/// the playlist ceiling must not quietly start refusing the requests it has
+/// just permitted. The old fixed 64 KiB stopped `createPlaylist` short of
+/// 1,490 tracks and `updatePlaylist` short of 1,338, against a ceiling of ten
+/// thousand.
+/// Still a bound: one request is buffered once, up to this, and a byte more is
+/// refused with error 10.
+pub const MAX_FORM_BYTES: usize = crate::services::MAX_PLAYLIST_TRACKS * 64 + 64 * 1024;
 
 /// How many album-less tracks a folder listing will carry.
 ///
diff --git a/src/webui.rs b/src/webui.rs
index f1d95caf..c655f490 100644
--- a/src/webui.rs
+++ b/src/webui.rs
@@ -50,6 +50,18 @@ const RESERVED_EXACT: [&str; 5] = [
     "favicon.ico",
 ];
 
+/// Files the installed client is made of (RFC-022 decision 4), answered as
+/// themselves or not at all.
+///
+/// Unlike [`RESERVED_EXACT`], these are looked up among the assets first: they
+/// are the client's, and a real build ships them. What they must never get is
+/// the fallback. A browser reading the manifest expects JSON and an icon an
+/// image; handed the shell, it fails to parse it and the client is not
+/// installable, with nothing in the response to say why. A build without them
+/// — the placeholder `build.rs` embeds — answers a JSON 404 instead.
+const ASSET_ONLY_EXACT: [&str; 2] = ["manifest.webmanifest", "apple-touch-icon.png"];
+const ASSET_ONLY_PREFIXES: [&str; 1] = ["icons/"];
+
 pub async fn handler(uri: Uri) -> Response {
     let path = uri.path().trim_start_matches('/');
     let reserved = RESERVED_PREFIXES
@@ -62,6 +74,13 @@ pub async fn handler(uri: Uri) -> Response {
     if let Some(response) = asset(path) {
         return response;
     }
+    let asset_only = ASSET_ONLY_EXACT.contains(&path)
+        || ASSET_ONLY_PREFIXES
+            .iter()
+            .any(|prefix| path.starts_with(prefix));
+    if asset_only {
+        return not_found();
+    }
     asset(INDEX).unwrap_or_else(missing_client)
 }
 
diff --git a/tests/media.rs b/tests/media.rs
index 0153f88d..63206552 100644
--- a/tests/media.rs
+++ b/tests/media.rs
@@ -874,6 +874,9 @@ async fn transcode_status_reports_the_ceilings_it_enforces() {
     assert_eq!(status["active"], 0);
     assert_eq!(status["global_limit"], config.transcode_global_limit);
     assert_eq!(status["per_user_limit"], config.transcode_per_user_limit);
+    // What a client may ask `format=` for, so it can offer AAC without
+    // guessing from a version number (RFC-022 decision 5).
+    assert_eq!(status["formats"], serde_json::json!(["mp3", "opus", "aac"]));
     // The pair is only useful if it bounds anything, and the config refuses the
     // other order at startup.
     assert!(
@@ -882,6 +885,131 @@ async fn transcode_status_reports_the_ceilings_it_enforces() {
     );
 }
 
+/// AAC is the third transcode, written as ADTS (RFC-022 decision 5).
+///
+/// The live answer is read the way a player reads it: its type, and the ADTS
+/// sync word at the first byte — a container with a header in front, an MP4
+/// for instance, would not start with one. The committed cache file is then
+/// asked of `ffprobe` rather than trusted, and served by byte range, which is
+/// the whole reason ADTS was chosen over a fragmented MP4 written to a pipe.
+#[tokio::test]
+async fn an_aac_transcode_streams_as_adts_and_seeks_once_cached() {
+    let (_temp, config, state) = test_app().await;
+    // Drawn at run time, never written down: a literal reaching the hash is
+    // what CodeQL reports as a hard-coded credential.
+    let password = uuid::Uuid::new_v4().to_string();
+    let hash = security::hash_password(&password).unwrap();
+    let owner = state
+        .db
+        .create_account("aac-owner", &hash, AccountRole::Admin, now_ms())
+        .await
+        .unwrap();
+    let music = config.data_dir.join("aac-music");
+    std::fs::create_dir_all(&music).unwrap();
+    // Three seconds, so the encode is many frames rather than one.
+    write_test_wav_of_len(&music.join("Aac.wav"), 8_000 * 3);
+    let root = std::fs::canonicalize(&music).unwrap();
+    let library_id = state
+        .db
+        .create_library(
+            owner,
+            "AAC library",
+            &root,
+            LibraryVisibility::Private,
+            now_ms(),
+        )
+        .await
+        .unwrap();
+    run_scan(
+        &state,
+        owner,
+        LibraryRecord {
+            id: library_id,
+            name: "AAC library".into(),
+            root_path: root,
+        },
+    )
+    .await;
+    let track = state
+        .db
+        .list_tracks_for_user(owner, library_id)
+        .await
+        .unwrap()
+        .pop()
+        .unwrap();
+    let router = waveflow_server::app(&config, state.clone());
+    let token = login_token(&router, "aac-owner", &password).await;
+    let uri = format!("/api/v2/tracks/{}/stream?format=aac&bitrate=64", track.id);
+    let get = |range: Option<&'static str>| {
+        let router = router.clone();
+        let uri = uri.clone();
+        let token = token.clone();
+        async move {
+            let mut request = Request::get(&uri).header("authorization", format!("Bearer {token}"));
+            if let Some(range) = range {
+                request = request.header("range", range);
+            }
+            router
+                .oneshot(request.body(Body::empty()).unwrap())
+                .await
+                .unwrap()
+        }
+    };
+
+    let live = get(None).await;
+    assert_eq!(live.status(), StatusCode::OK);
+    assert_eq!(live.headers()["content-type"], "audio/aac");
+    assert_eq!(live.headers()["accept-ranges"], "none");
+    let bytes = live.into_body().collect().await.unwrap().to_bytes();
+    assert!(bytes.len() > 100, "{} bytes", bytes.len());
+    assert!(
+        bytes[0] == 0xFF && bytes[1] & 0xF0 == 0xF0,
+        "no ADTS sync word at the first byte: {:02x} {:02x}",
+        bytes[0],
+        bytes[1]
+    );
+
+    let cached = wait_for_cache_file(&config.transcode_cache_dir, "aac").await;
+    let probe = std::process::Command::new("ffprobe")
+        .args([
+            "-v",
+            "error",
+            "-show_entries",
+            "format=format_name:stream=codec_name",
+            "-of",
+            "default=noprint_wrappers=1",
+        ])
+        .arg(&cached)
+        .output()
+        .expect("ffprobe must be on PATH");
+    let probe = String::from_utf8_lossy(&probe.stdout);
+    assert!(probe.contains("codec_name=aac"), "{probe}");
+    assert!(probe.contains("format_name=aac"), "{probe}");
+
+    let ranged = get(Some("bytes=0-31")).await;
+    assert_eq!(ranged.status(), StatusCode::PARTIAL_CONTENT);
+    assert_eq!(ranged.headers()["content-type"], "audio/aac");
+    assert_eq!(
+        ranged.into_body().collect().await.unwrap().to_bytes().len(),
+        32
+    );
+
+    // The native API still refuses a format it cannot produce: its clients
+    // read `formats` from the status route, and only the Subsonic façade falls
+    // back (RFC-022 decision 6).
+    let unknown = router
+        .clone()
+        .oneshot(
+            Request::get(format!("/api/v2/tracks/{}/stream?format=flac", track.id))
+                .header("authorization", format!("Bearer {token}"))
+                .body(Body::empty())
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    assert_eq!(unknown.status(), StatusCode::BAD_REQUEST);
+}
+
 /// The client is compressed; the stream is not, and still accepts ranges.
 ///
 /// Both halves in one test because either alone is reassuring and neither is
diff --git a/tests/native_api.rs b/tests/native_api.rs
index 538480b5..b5486ed3 100644
--- a/tests/native_api.rs
+++ b/tests/native_api.rs
@@ -5584,3 +5584,232 @@ async fn chosen_artist_images_lead_every_reader_and_outlive_the_portrait_fill()
         StatusCode::NOT_FOUND
     );
 }
+
+/// An artist page groups the discography by release type and lists what the
+/// artist appears on (RFC-022 decisions 2 and 3).
+///
+/// The fixture holds one album per group, one album with no type at all, and
+/// two albums by someone else: one with a guest track by the artist, which is
+/// an appearance, and one crediting the artist only as composer, which is not.
+/// An album the artist is album artist of credits them on every track as
+/// well, so those six are the case that proves the exclusion.
+#[tokio::test]
+async fn an_artist_page_groups_its_discography_and_lists_its_appearances() {
+    let (_temp, config, state) = test_app().await;
+    // Drawn at run time: a literal reaching the hash is a hard-coded
+    // credential to CodeQL.
+    let password = uuid::Uuid::new_v4().to_string();
+    let hash = security::hash_password(&password).unwrap();
+    let owner = state
+        .db
+        .create_account("discography-owner", &hash, AccountRole::Admin, now_ms())
+        .await
+        .unwrap();
+    state
+        .db
+        .create_account("discography-outsider", &hash, AccountRole::User, now_ms())
+        .await
+        .unwrap();
+    let root = config.data_dir.join("discography");
+    std::fs::create_dir_all(&root).unwrap();
+    let library_id = state
+        .db
+        .create_library(
+            owner,
+            "Discography",
+            &std::fs::canonicalize(&root).unwrap(),
+            LibraryVisibility::Private,
+            now_ms(),
+        )
+        .await
+        .unwrap();
+    let scan_id = state
+        .db
+        .create_scan_job(library_id, Some(owner), "manual")
+        .await
+        .unwrap();
+    // (title, album, album artist, track artist, release types, year)
+    let fixture = [
+        (
+            "One",
+            "Long Player",
+            "Disco Artist",
+            "Disco Artist",
+            Some("album"),
+            2001,
+        ),
+        (
+            "Two",
+            "Short Player",
+            "Disco Artist",
+            "Disco Artist",
+            Some("EP"),
+            2002,
+        ),
+        (
+            "Three",
+            "Lone Song",
+            "Disco Artist",
+            "Disco Artist",
+            Some("single"),
+            2003,
+        ),
+        (
+            "Four",
+            "On Stage",
+            "Disco Artist",
+            "Disco Artist",
+            Some("album/live"),
+            2004,
+        ),
+        (
+            "Five",
+            "Best Of",
+            "Disco Artist",
+            "Disco Artist",
+            Some("album; compilation"),
+            2005,
+        ),
+        ("Six", "Untyped", "Disco Artist", "Disco Artist", None, 2006),
+        (
+            "Seven",
+            "Guest Spot",
+            "Host Artist",
+            "Host Artist; Disco Artist",
+            Some("album"),
+            2010,
+        ),
+        (
+            "Eight",
+            "Guest Spot",
+            "Host Artist",
+            "Host Artist",
+            Some("album"),
+            2010,
+        ),
+        (
+            "Nine",
+            "Written For",
+            "Host Artist",
+            "Host Artist",
+            Some("album"),
+            2011,
+        ),
+    ];
+    state
+        .db
+        .start_scan_job(scan_id, fixture.len() as i64, false)
+        .await
+        .unwrap();
+    for (index, (title, album, album_artist, artist, types, year)) in
+        fixture.into_iter().enumerate()
+    {
+        let mut input = browse_input(index + 3_000, title, album, album_artist, Some(1), Some(1));
+        input.artist = Some(artist.into());
+        input.release_types = types.map(str::to_owned);
+        input.year = Some(year);
+        input.track_number = Some(index as i64 + 1);
+        if title == "Nine" {
+            input.roles = vec![(
+                waveflow_server::tags::Role::Composer,
+                vec!["Disco Artist".into()],
+            )];
+        }
+        state
+            .db
+            .apply_catalog_track(library_id, scan_id, &input, None, false)
+            .await
+            .unwrap();
+    }
+    state
+        .db
+        .consolidate_catalog_derivations(library_id)
+        .await
+        .unwrap();
+    state.db.finish_scan_job(scan_id, 0).await.unwrap();
+
+    let router = waveflow_server::app(&config, state);
+    let owner_token = login_token(&router, "discography-owner", &password).await;
+    let outsider_token = login_token(&router, "discography-outsider", &password).await;
+    let get = |uri: String, token: String| {
+        let router = router.clone();
+        async move {
+            router
+                .oneshot(
+                    Request::get(uri)
+                        .header("authorization", format!("Bearer {token}"))
+                        .body(Body::empty())
+                        .unwrap(),
+                )
+                .await
+                .unwrap()
+        }
+    };
+    let artists = json_body(get("/api/v2/artists".into(), owner_token.clone()).await).await;
+    let artist_id = artists
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|artist| artist["name"] == "Disco Artist")
+        .expect("the artist is listed")["id"]
+        .as_str()
+        .unwrap()
+        .to_owned();
+
+    let page = get(format!("/api/v2/artists/{artist_id}"), owner_token.clone()).await;
+    assert_eq!(page.status(), StatusCode::OK);
+    let page = json_body(page).await;
+    let groups = page["albums"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .map(|album| {
+            (
+                album["title"].as_str().unwrap().to_owned(),
+                album["release_group"].as_str().unwrap().to_owned(),
+            )
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(
+        groups,
+        [
+            ("Long Player", "album"),
+            ("Short Player", "ep"),
+            ("Lone Song", "single"),
+            ("On Stage", "live"),
+            ("Best Of", "compilation"),
+            ("Untyped", "album"),
+        ]
+        .map(|(title, group)| (title.to_owned(), group.to_owned()))
+    );
+    // What the files said is still carried beside the decision about it.
+    assert_eq!(
+        page["albums"][3]["release_types"],
+        serde_json::json!(["album/live"])
+    );
+
+    // The guest track's album, and only it: not the albums whose every track
+    // credits the artist, and not the one that credits them as composer.
+    let appears_on = page["appears_on"]
+        .as_array()
+        .expect("the native page lists appearances");
+    assert_eq!(appears_on.len(), 1, "{appears_on:?}");
+    assert_eq!(appears_on[0]["title"], "Guest Spot");
+    assert_eq!(appears_on[0]["artist"], "Host Artist");
+
+    // The album-artist list on its own is unchanged: appearances are the
+    // page's, not the artist's albums.
+    let albums_of = json_body(
+        get(
+            format!("/api/v2/artists/{artist_id}/albums"),
+            owner_token.clone(),
+        )
+        .await,
+    )
+    .await;
+    assert_eq!(albums_of, page["albums"]);
+
+    // Someone outside the library is told nothing, appearances included.
+    let hidden = get(format!("/api/v2/artists/{artist_id}"), outsider_token).await;
+    assert_eq!(hidden.status(), StatusCode::NOT_FOUND);
+}
diff --git a/tests/service.rs b/tests/service.rs
index 2434ee4f..46d0fca5 100644
--- a/tests/service.rs
+++ b/tests/service.rs
@@ -210,6 +210,69 @@ async fn probes_and_openapi_are_available_without_scan_readiness() {
     );
 }
 
+/// The files that make the client installable are served as themselves, or
+/// answered a JSON 404 — never the shell (RFC-022 decision 4).
+///
+/// Holds whether or not a client build is embedded in the binary under test,
+/// which is what lets it run in both CI jobs: with a build, each file must
+/// arrive with its own type and the manifest must parse; with the placeholder,
+/// each must be a definitive 404. The one answer it can never accept is
+/// `text/html`, which is what the router fallback gives any path it does not
+/// know, and which a browser reading a manifest fails on without saying why.
+#[tokio::test]
+async fn the_install_manifest_and_icons_are_never_answered_with_the_shell() {
+    let (_temp, config, state) = test_app().await;
+    let router = waveflow_server::app(&config, state);
+    for (path, expected) in [
+        ("/manifest.webmanifest", "application/manifest+json"),
+        ("/apple-touch-icon.png", "image/png"),
+        ("/icons/icon-192.png", "image/png"),
+        ("/icons/icon-512.png", "image/png"),
+        ("/icons/maskable-512.png", "image/png"),
+        ("/icons/not-shipped.png", "image/png"),
+    ] {
+        let response = router
+            .clone()
+            .oneshot(Request::get(path).body(Body::empty()).unwrap())
+            .await
+            .unwrap();
+        let status = response.status();
+        let kind = response
+            .headers()
+            .get("content-type")
+            .map(|value| value.to_str().unwrap().to_owned())
+            .unwrap_or_default();
+        assert!(!kind.starts_with("text/html"), "{path} answered the shell");
+        match status {
+            StatusCode::OK => {
+                assert_eq!(kind, expected, "{path}");
+                if path == "/manifest.webmanifest" {
+                    let manifest: serde_json::Value =
+                        serde_json::from_str(&body_text(response).await).unwrap();
+                    assert_eq!(manifest["start_url"], "/");
+                    assert_eq!(manifest["display"], "standalone");
+                    assert!(manifest["icons"].as_array().is_some_and(|icons| icons
+                        .iter()
+                        .any(|icon| icon["purpose"] == "maskable")));
+                }
+            }
+            StatusCode::NOT_FOUND => assert!(kind.starts_with("application/json"), "{path}"),
+            other => panic!("{path} answered {other}"),
+        }
+    }
+    // A name the build never ships is a 404 whatever is embedded.
+    let missing = router
+        .clone()
+        .oneshot(
+            Request::get("/icons/not-shipped.png")
+                .body(Body::empty())
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    assert_eq!(missing.status(), StatusCode::NOT_FOUND);
+}
+
 #[tokio::test]
 async fn embedded_web_client_serves_shell_without_shadowing_the_api() {
     let (_temp, config, state) = test_app().await;
diff --git a/tests/subsonic_methods.rs b/tests/subsonic_methods.rs
index 20c57883..917b4bf7 100644
--- a/tests/subsonic_methods.rs
+++ b/tests/subsonic_methods.rs
@@ -896,3 +896,313 @@ async fn internet_radio_stations_are_kept_per_account_and_handed_out_never_fetch
     .await;
     assert_eq!(state.services.radio_stations(owner).await.unwrap().len(), 1);
 }
+
+/// A playlist as long as the domain allows fits in one form POST, and the body
+/// is still bounded (RFC-022 decision 7).
+///
+/// `formPost` exists for requests too long for a URL, and the longest one a
+/// client sends is a playlist edit naming every track. The old fixed 64 KiB
+/// refused `updatePlaylist` short of 1,338 identifiers — `songIdToAdd=<uuid>&` is
+/// forty-nine bytes — against a ceiling of ten thousand. The edit here names
+/// exactly that ceiling, so it fails under the old bound and passes under the
+/// new one; the second half sends one byte more than the bound and must still
+/// be refused, so the bound cannot have quietly gone away.
+#[tokio::test]
+async fn a_playlist_as_long_as_the_domain_allows_fits_in_one_form_post() {
+    let (_temp, config, state) = test_app().await;
+    // Inserted rather than created, every credential drawn at run time: see
+    // the radio test above for why.
+    let owner = Uuid::new_v4();
+    sqlx::query(
+        "INSERT INTO account (id, username, password_hash, role, disabled, created_at, updated_at) \
+         VALUES (?, 'form-owner', 'this-account-never-authenticates', 'admin', 0, ?, ?)",
+    )
+    .bind(owner.to_string())
+    .bind(now_ms())
+    .bind(now_ms())
+    .execute(state.db.pool())
+    .await
+    .unwrap();
+    let api_key = format!("wfsk_{}", Uuid::new_v4());
+    state
+        .db
+        .set_subsonic_credential(
+            owner,
+            owner,
+            &state
+                .secret_box
+                .encrypt(Uuid::new_v4().to_string().as_bytes())
+                .unwrap(),
+            &security::token_hash(&api_key),
+            now_ms(),
+        )
+        .await
+        .unwrap();
+    let root = config.data_dir.join("form-library");
+    std::fs::create_dir_all(&root).unwrap();
+    let library = state
+        .db
+        .create_library(
+            owner,
+            "form-library",
+            &std::fs::canonicalize(&root).unwrap(),
+            LibraryVisibility::Private,
+            now_ms(),
+        )
+        .await
+        .unwrap();
+    let scan = state
+        .db
+        .create_scan_job(library, Some(owner), "manual")
+        .await
+        .unwrap();
+    state.db.start_scan_job(scan, 1, false).await.unwrap();
+    let input = browse_input(0, "Repeat", "Form Album", "Form Artist", Some(1), Some(1));
+    state
+        .db
+        .apply_catalog_track(library, scan, &input, None, false)
+        .await
+        .unwrap();
+    state
+        .db
+        .consolidate_catalog_derivations(library)
+        .await
+        .unwrap();
+    state.db.finish_scan_job(scan, 0).await.unwrap();
+    let song = state
+        .services
+        .catalog_snapshot(owner, &[])
+        .await
+        .unwrap()
+        .songs[0]
+        .id;
+    // A playlist holds a track once (`playlist_track` is keyed on the pair), so
+    // reaching the ceiling takes that many distinct tracks. Ten thousand
+    // through the catalogue writer would take minutes; copying the one row in
+    // SQL gives the same projection, since everything a playlist reads of a
+    // track is on that row. Each copy gets its own id and path, the two
+    // columns the table holds unique.
+    let ceiling = waveflow_server::services::MAX_PLAYLIST_TRACKS;
+    // One connection throughout: a temporary table belongs to the connection
+    // that made it.
+    let mut connection = state.db.pool().acquire().await.unwrap();
+    sqlx::query(
+        "CREATE TEMP TABLE copies AS \
+         WITH RECURSIVE n(i) AS (SELECT 1 UNION ALL SELECT i + 1 FROM n WHERE i < ?) \
+         SELECT t.*, n.i AS copy_number FROM track t, n WHERE t.id = ?",
+    )
+    .bind(ceiling as i64 - 1)
+    .bind(song.to_string())
+    .execute(&mut *connection)
+    .await
+    .unwrap();
+    for statement in [
+        "UPDATE copies SET id = printf('%08x-0000-4000-8000-%012x', copy_number, copy_number), \
+         relative_path = 'copy-' || copy_number || '.flac'",
+        "ALTER TABLE copies DROP COLUMN copy_number",
+        "INSERT INTO track SELECT * FROM copies",
+        "DROP TABLE copies",
+    ] {
+        sqlx::query(statement)
+            .execute(&mut *connection)
+            .await
+            .unwrap();
+    }
+    drop(connection);
+    let tracks = state
+        .services
+        .catalog_snapshot(owner, &[])
+        .await
+        .unwrap()
+        .songs
+        .into_iter()
+        .map(|song| song.id.to_string())
+        .collect::<Vec<_>>();
+    assert_eq!(tracks.len(), ceiling);
+    let router = waveflow_server::app(&config, state.clone());
+    let created = subsonic_json(&router, "createPlaylist", &api_key, "&name=Long").await;
+    let playlist = created["subsonic-response"]["playlist"]["id"]
+        .as_str()
+        .unwrap()
+        .to_owned();
+
+    let post = |body: String| {
+        let router = router.clone();
+        async move {
+            let response = router
+                .oneshot(
+                    // `f` in the query string as well: a body refused for its
+                    // size is never read, so it cannot carry the format.
+                    Request::post("/rest/updatePlaylist.view?f=json")
+                        .header("content-type", "application/x-www-form-urlencoded")
+                        .body(Body::from(body))
+                        .unwrap(),
+                )
+                .await
+                .unwrap();
+            assert_eq!(response.status(), StatusCode::OK);
+            json_body(response).await
+        }
+    };
+
+    let mut body = format!("apiKey={api_key}&v=1.16.1&c=golden&f=json&playlistId={playlist}");
+    for track in &tracks {
+        body.push_str("&songIdToAdd=");
+        body.push_str(track);
+    }
+    assert!(
+        body.len() > 64 * 1024,
+        "the request must be one the old bound refused"
+    );
+    let filled = post(body).await;
+    assert_eq!(
+        filled["subsonic-response"]["status"], "ok",
+        "{}",
+        filled["subsonic-response"]["error"]
+    );
+    let listed = subsonic_json(&router, "getPlaylists", &api_key, "").await;
+    assert_eq!(
+        listed["subsonic-response"]["playlists"]["playlist"][0]["songCount"],
+        ceiling
+    );
+
+    // One byte past the bound is refused before anything reads it, and the
+    // refusal is the façade's own, in the body of an HTTP 200.
+    let limit = waveflow_server::subsonic::MAX_FORM_BYTES;
+    let mut over = format!("apiKey={api_key}&v=1.16.1&c=golden&f=json&padding=");
+    over.push_str(&"a".repeat(limit + 1 - over.len()));
+    assert_eq!(over.len(), limit + 1);
+    let refused = post(over).await;
+    assert_eq!(refused["subsonic-response"]["error"]["code"], 10);
+    assert_eq!(
+        refused["subsonic-response"]["error"]["message"],
+        "Invalid form body"
+    );
+    // A body exactly at the bound is read: whatever refuses it, if anything,
+    // is not its size.
+    let mut exact = format!("apiKey={api_key}&v=1.16.1&c=golden&f=json&padding=");
+    exact.push_str(&"a".repeat(limit - exact.len()));
+    assert_eq!(exact.len(), limit);
+    let read = post(exact).await;
+    assert_ne!(
+        read["subsonic-response"]["error"]["message"],
+        "Invalid form body"
+    );
+}
+
+/// A format the façade cannot produce plays something rather than nothing
+/// (RFC-022 decision 6), and `aac` is one it can (decision 5).
+///
+/// The unknown format is read as no format at all: the original while the cap
+/// admits it, MP3 at the cap when it does not — exactly the answers a request
+/// naming no format already gets, so the fallback adds no path of its own. Each
+/// answer is identified by its `Content-Type` and its first bytes, because a
+/// refusal is an HTTP 200 too and would pass a status check.
+#[tokio::test]
+async fn a_format_the_facade_cannot_produce_falls_back_and_aac_is_produced() {
+    let (_temp, config, state) = test_app().await;
+    let owner = Uuid::new_v4();
+    sqlx::query(
+        "INSERT INTO account (id, username, password_hash, role, disabled, created_at, updated_at) \
+         VALUES (?, 'format-owner', 'this-account-never-authenticates', 'admin', 0, ?, ?)",
+    )
+    .bind(owner.to_string())
+    .bind(now_ms())
+    .bind(now_ms())
+    .execute(state.db.pool())
+    .await
+    .unwrap();
+    let api_key = format!("wfsk_{}", Uuid::new_v4());
+    state
+        .db
+        .set_subsonic_credential(
+            owner,
+            owner,
+            &state
+                .secret_box
+                .encrypt(Uuid::new_v4().to_string().as_bytes())
+                .unwrap(),
+            &security::token_hash(&api_key),
+            now_ms(),
+        )
+        .await
+        .unwrap();
+    let music = config.data_dir.join("format-music");
+    std::fs::create_dir_all(&music).unwrap();
+    write_test_wav_of_len(&music.join("Format.wav"), 8_000);
+    let root = std::fs::canonicalize(&music).unwrap();
+    let library = state
+        .db
+        .create_library(
+            owner,
+            "Formats",
+            &root,
+            LibraryVisibility::Private,
+            now_ms(),
+        )
+        .await
+        .unwrap();
+    run_scan(
+        &state,
+        owner,
+        waveflow_server::catalog::LibraryRecord {
+            id: library,
+            name: "Formats".into(),
+            root_path: root,
+        },
+    )
+    .await;
+    let song = state
+        .services
+        .catalog_snapshot(owner, &[])
+        .await
+        .unwrap()
+        .songs[0]
+        .id;
+    let router = waveflow_server::app(&config, state.clone());
+    let stream = |extra: &'static str| {
+        let router = router.clone();
+        let uri = format!("/rest/stream.view?apiKey={api_key}&id={song}&v=1.16.1&c=golden{extra}");
+        async move {
+            let response = router
+                .oneshot(Request::get(uri).body(Body::empty()).unwrap())
+                .await
+                .unwrap();
+            assert_eq!(response.status(), StatusCode::OK, "{extra}");
+            let kind = response.headers()["content-type"]
+                .to_str()
+                .unwrap()
+                .to_owned();
+            let bytes = http_body_util::BodyExt::collect(response.into_body())
+                .await
+                .unwrap()
+                .to_bytes();
+            (kind, bytes)
+        }
+    };
+
+    // Asked for FLAC over a WAV: the original, which is what the client is
+    // after, where it used to be error 10.
+    for extra in ["&format=flac", "&format=wav", "&format=nonsense"] {
+        let (kind, bytes) = stream(extra).await;
+        assert_eq!(kind, "audio/wav", "{extra}");
+        assert!(bytes.starts_with(b"RIFF"), "{extra}");
+    }
+    // Under a cap the source exceeds, the same fallback a request naming no
+    // format takes: MP3 at the cap.
+    let (kind, bytes) = stream("&format=flac&maxBitRate=32").await;
+    assert_eq!(kind, "audio/mpeg");
+    assert!(bytes.len() > 32);
+    // AAC is produced, under each name a client spells it with.
+    for extra in ["&format=aac", "&format=m4a", "&format=AAC"] {
+        let (kind, bytes) = stream(extra).await;
+        assert_eq!(kind, "audio/aac", "{extra}");
+        assert!(bytes[0] == 0xFF && bytes[1] & 0xF0 == 0xF0, "{extra}");
+    }
+    // And the formats it always knew are untouched.
+    let (kind, _) = stream("&format=mp3").await;
+    assert_eq!(kind, "audio/mpeg");
+    let (kind, bytes) = stream("&format=raw").await;
+    assert_eq!(kind, "audio/wav");
+    assert!(bytes.starts_with(b"RIFF"));
+}

From 3aaff914ecdaf5802e705794114852b497b507c7 Mon Sep 17 00:00:00 2001
From: InstaZDLL <github.105mh@8shield.net>
Date: Sun, 25 Oct 2026 02:26:31 +0200
Subject: [PATCH 3/8] feat(webapp): replaygain, discography sections and an
 installable client (RFC-022)

The player levels each track by its ReplayGain through a GainNode fed by the audio element: off, track or album, falling back to the other pair, a preamp from -12 to +12 dB applied to tagged tracks only, and capped at 1/peak against clipping. Off by default; the graph is built on the next play the listener starts, never on load. The preference is stored per browser beside the theme. The artist page shows Albums, EPs, Singles, Live, Compilations and Appears on from the server's release_group and appears_on. A web app manifest, PNG icons rendered from the mark, and an apple-touch-icon make the client installable; there is no service worker.

Signed-off-by: InstaZDLL <github.105mh@8shield.net>
---
 webapp/e2e/studio-nocturne.spec.ts   | 243 ++++++++++++++++++++++++++-
 webapp/index.html                    |   7 +
 webapp/public/apple-touch-icon.png   | Bin 0 -> 8692 bytes
 webapp/public/icons/icon-192.png     | Bin 0 -> 13631 bytes
 webapp/public/icons/icon-512.png     | Bin 0 -> 107787 bytes
 webapp/public/icons/maskable-512.png | Bin 0 -> 88255 bytes
 webapp/public/manifest.webmanifest   |  31 ++++
 webapp/scripts/render-icons.ts       |  83 +++++++++
 webapp/src/api/catalog.ts            |  22 +++
 webapp/src/lib/discography.test.ts   |  66 ++++++++
 webapp/src/lib/discography.ts        |  62 +++++++
 webapp/src/lib/replay-gain.test.ts   | 136 +++++++++++++++
 webapp/src/lib/replay-gain.ts        | 147 ++++++++++++++++
 webapp/src/pages/artist-page.tsx     |  51 +++++-
 webapp/src/pages/settings-page.tsx   |   6 +-
 webapp/src/player/player.tsx         | 117 ++++++++++---
 webapp/src/state/i18n.tsx            |  28 +++
 webapp/src/state/preferences.tsx     | 133 ++++++++++++++-
 webapp/src/styles/fluid.css          |   1 +
 webapp/src/styles/refresh.css        |  35 ++++
 webapp/src/styles/styles.css         |   2 +
 21 files changed, 1143 insertions(+), 27 deletions(-)
 create mode 100644 webapp/public/apple-touch-icon.png
 create mode 100644 webapp/public/icons/icon-192.png
 create mode 100644 webapp/public/icons/icon-512.png
 create mode 100644 webapp/public/icons/maskable-512.png
 create mode 100644 webapp/public/manifest.webmanifest
 create mode 100644 webapp/scripts/render-icons.ts
 create mode 100644 webapp/src/lib/discography.test.ts
 create mode 100644 webapp/src/lib/discography.ts
 create mode 100644 webapp/src/lib/replay-gain.test.ts
 create mode 100644 webapp/src/lib/replay-gain.ts

diff --git a/webapp/e2e/studio-nocturne.spec.ts b/webapp/e2e/studio-nocturne.spec.ts
index 3aed9511..5df9e7e2 100644
--- a/webapp/e2e/studio-nocturne.spec.ts
+++ b/webapp/e2e/studio-nocturne.spec.ts
@@ -208,6 +208,12 @@ const song = (
   sample_rate: 44_100,
   channels: 2,
   bit_depth: 16,
+  // ReplayGain as tagged, different per track so a test can tell which one
+  // the player levelled. The album's pair is shared, as on a real record.
+  replay_gain_track_gain: -6 - index,
+  replay_gain_track_peak: 0.9,
+  replay_gain_album_gain: -8,
+  replay_gain_album_peak: 0.95,
 });
 
 const albumDetail = {
@@ -242,6 +248,11 @@ let artistPlayed: Array<ReturnType<typeof song>> = [];
 let topSongAsks: Array<string | null> = [];
 /** How many times the artist page was asked for. */
 let artistAsks = 0;
+/**
+ * Fields laid over the artist's answer: the RFC-022 sections and appearances.
+ * Empty by default, which is what a server from before RFC-022 sends.
+ */
+let artistExtra: Record<string, unknown> = {};
 /**
  * The `enrichment` object of the artist's nth answer, counting from one.
  * Undefined leaves it out, as a server from before RFC-011 does.
@@ -1085,7 +1096,11 @@ async function mockAuthenticatedApi(page: Page) {
         return;
       }
       await route.fulfill({
-        json: { ...artistDetail, enrichment: enrichmentOf(artistAsks) },
+        json: {
+          ...artistDetail,
+          ...artistExtra,
+          enrichment: enrichmentOf(artistAsks),
+        },
       });
       return;
     }
@@ -1116,6 +1131,7 @@ test.beforeEach(async ({ page }) => {
   artistPlayed = [song(2, "Cocoon", 0, false), song(1, "Hidden Place", 5, true)];
   topSongAsks = [];
   artistAsks = 0;
+  artistExtra = {};
   enrichmentOf = () => undefined;
   artistFailsAfterFirst = false;
   // **Reset here, and they were not.** These four reached the mock without
@@ -6535,3 +6551,228 @@ test("asks for the header again on every visit", async ({
   await sidebar.getByRole("link", { name: "Quality" }).click();
   await expect(page.getByText("2 of 3 lossless files analysed")).toBeVisible();
 });
+
+/**
+ * RFC-022 decisions 2 and 3 on the screen: the albums in the sections the
+ * server filed them under, in the page's order whatever order they came in,
+ * empty sections left out, and the appearances last.
+ */
+test("an artist page files its records by type, and lists what it appears on", async ({
+  page,
+}) => {
+  artistExtra = {
+    albums: [
+      { ...albums[1], id: "album-3", title: "Vespertine Live", release_group: "live" },
+      { ...albums[0], release_group: "album" },
+      { ...albums[1], release_group: "album" },
+    ],
+    appears_on: [
+      {
+        ...albums[0],
+        id: "album-9",
+        title: "Guest Spot",
+        artist: "Someone Else",
+        artist_id: "artist-9",
+        release_group: "album",
+      },
+    ],
+  };
+  await page.goto("/artists/artist-1");
+  await expect(
+    page.getByRole("heading", { name: "Björk", level: 2 }),
+  ).toBeVisible();
+  await expect(page.locator(".artist-discography h3")).toHaveText([
+    "Albums",
+    "Live",
+    "Appears on",
+  ]);
+  const appearances = page.getByRole("region", { name: "Appears on" });
+  await expect(appearances.getByText("Guest Spot", { exact: true })).toBeVisible();
+  await expect(appearances.getByText("Someone Else")).toBeVisible();
+  // Filed under its own section, and nowhere else.
+  await expect(
+    page.getByRole("region", { name: "Live" }).getByText("Vespertine Live"),
+  ).toBeVisible();
+  await expect(
+    page.getByRole("region", { name: "Albums" }).getByText("Vespertine Live"),
+  ).toHaveCount(0);
+  await expectNoWcagViolations(page);
+});
+
+/**
+ * An older server sends no groups and no appearances: one section, the one
+ * the page always had.
+ */
+test("an artist page from a server without release groups keeps one section", async ({
+  page,
+}) => {
+  await page.goto("/artists/artist-1");
+  await expect(page.locator(".artist-discography h3")).toHaveText(["Albums"]);
+  await expect(
+    page.getByRole("region", { name: "Albums" }).getByText("Vespertine", { exact: true }),
+  ).toBeVisible();
+});
+
+/**
+ * RFC-022 decision 1: ReplayGain is off until asked for, and asking for it is
+ * what builds the Web Audio graph — on the next play, never on page load.
+ *
+ * The browser's own `AudioContext` and `AudioParam` are wrapped to count
+ * contexts and record the gains set, because the level a track is played at
+ * cannot be heard by a test. What can be read is that no context exists while
+ * the setting is off, that exactly one exists once a play follows turning it
+ * on, and that the gain set is the one the tags and the preamp call for.
+ */
+test("levels a track by its ReplayGain only once asked to, and remembers how", async ({
+  page,
+}) => {
+  await page.addInitScript(() => {
+    const record = window as unknown as {
+      __contexts: number;
+      __gains: number[];
+    };
+    record.__contexts = 0;
+    record.__gains = [];
+    const setValueAtTime = AudioParam.prototype.setValueAtTime;
+    AudioParam.prototype.setValueAtTime = function (value, time) {
+      record.__gains.push(value);
+      return setValueAtTime.call(this, value, time);
+    };
+    const Original = window.AudioContext;
+    window.AudioContext = class extends Original {
+      constructor(options?: AudioContextOptions) {
+        super(options);
+        record.__contexts += 1;
+      }
+    };
+  });
+  const contexts = () =>
+    page.evaluate(() => (window as unknown as { __contexts: number }).__contexts);
+  const gains = () =>
+    page.evaluate(() => (window as unknown as { __gains: number[] }).__gains);
+
+  // Off by default: playing builds nothing.
+  await page.goto("/albums/album-2");
+  await page.getByRole("button", { name: "Play album" }).click();
+  await expect(page.locator(".player-track strong")).toHaveText("Hidden Place");
+  expect(await contexts()).toBe(0);
+
+  await page.goto("/settings");
+  const playback = page.locator(".settings-panel", {
+    has: page.getByRole("heading", { name: "Playback" }),
+  });
+  // The preamp changes nothing while ReplayGain is off, so it is not offered.
+  await expect(playback.getByRole("slider", { name: "Preamp" })).toHaveCount(0);
+  await playback.getByLabel("ReplayGain").selectOption("album");
+  const preamp = playback.getByRole("slider", { name: "Preamp" });
+  await expect(preamp).toBeVisible();
+  await preamp.fill("3");
+  await expect(playback.locator("output")).toHaveText("+3 dB");
+  await expect
+    .poll(() => page.evaluate(() => localStorage.getItem("waveflow.replayGain")))
+    .toBe(JSON.stringify({ mode: "album", preampDb: 3 }));
+  await expectNoWcagViolations(page);
+  // Choosing it is not playing: still no graph.
+  expect(await contexts()).toBe(0);
+
+  // Remembered across a reload, and applied on the next play: the album gain
+  // of −8 dB plus the 3 dB preamp, well under what the 0.95 peak allows.
+  await page.goto("/albums/album-2");
+  await page.getByRole("button", { name: "Play album" }).click();
+  await expect(page.locator(".player-track strong")).toHaveText("Hidden Place");
+  await expect.poll(contexts).toBe(1);
+  await expect
+    .poll(async () => (await gains()).at(-1))
+    .toBeCloseTo(10 ** (-5 / 20), 4);
+
+  // Track mode levels by the track's own gain: −7 dB for the first track.
+  await page.goto("/settings");
+  await page.getByLabel("ReplayGain").selectOption("track");
+  await page.goto("/albums/album-2");
+  await page.getByRole("button", { name: "Play album" }).click();
+  await expect
+    .poll(async () => (await gains()).at(-1))
+    .toBeCloseTo(10 ** (-4 / 20), 4);
+});
+
+/**
+ * RFC-022 decision 4: the client declares a manifest a phone can install from,
+ * and every icon it names is served as an image.
+ */
+test("declares an install manifest whose icons are all served", async ({
+  page,
+}, testInfo) => {
+  test.skip(testInfo.project.name !== "desktop", "one viewport is enough");
+  await page.goto("/");
+  await expect(page.locator('link[rel="manifest"]')).toHaveAttribute(
+    "href",
+    "/manifest.webmanifest",
+  );
+  await expect(page.locator('link[rel="apple-touch-icon"]')).toHaveAttribute(
+    "href",
+    "/apple-touch-icon.png",
+  );
+  const response = await page.request.get("/manifest.webmanifest");
+  expect(response.status()).toBe(200);
+  expect(response.headers()["content-type"]).toContain(
+    "application/manifest+json",
+  );
+  const manifest = (await response.json()) as {
+    start_url: string;
+    display: string;
+    icons: Array<{ src: string; sizes: string; purpose: string }>;
+  };
+  expect(manifest.start_url).toBe("/");
+  expect(manifest.display).toBe("standalone");
+  expect(manifest.icons.map((icon) => icon.sizes)).toEqual(
+    expect.arrayContaining(["192x192", "512x512"]),
+  );
+  expect(manifest.icons.some((icon) => icon.purpose === "maskable")).toBe(true);
+  for (const src of [
+    ...manifest.icons.map((icon) => icon.src),
+    "/apple-touch-icon.png",
+  ]) {
+    const icon = await page.request.get(src);
+    expect(icon.status(), src).toBe(200);
+    expect(icon.headers()["content-type"], src).toContain("image/png");
+  }
+});
+
+/**
+ * The two RFC-022 screens in the light appearance, whose contrast the dark
+ * default's sweep says nothing about: the playback settings with the preamp
+ * showing, and an artist page with every kind of section.
+ */
+test("keeps the playback settings and the discography readable in light", async ({
+  page,
+}) => {
+  await page.addInitScript(() => {
+    localStorage.setItem("waveflow.theme", "default");
+    localStorage.setItem(
+      "waveflow.replayGain",
+      JSON.stringify({ mode: "track", preampDb: -2 }),
+    );
+  });
+  await page.goto("/settings");
+  await expect(page.locator("html")).toHaveAttribute("data-theme", "default");
+  await expect(page.getByRole("slider", { name: "Preamp" })).toHaveValue("-2");
+  await expect(page.locator(".replay-gain-preamp output")).toHaveText("−2 dB");
+  await expectNoWcagViolations(page);
+
+  artistExtra = {
+    albums: [
+      { ...albums[0], release_group: "album" },
+      { ...albums[1], id: "album-4", title: "Single Cut", release_group: "single" },
+      { ...albums[1], id: "album-5", title: "Best Of", release_group: "compilation" },
+    ],
+    appears_on: [{ ...albums[0], id: "album-9", title: "Guest Spot", artist: "Someone Else" }],
+  };
+  await page.goto("/artists/artist-1");
+  await expect(page.locator(".artist-discography h3")).toHaveText([
+    "Albums",
+    "Singles",
+    "Compilations",
+    "Appears on",
+  ]);
+  await expectNoWcagViolations(page);
+});
diff --git a/webapp/index.html b/webapp/index.html
index fde4378e..eb6dbefd 100644
--- a/webapp/index.html
+++ b/webapp/index.html
@@ -15,6 +15,13 @@
          HTML as an image, and it asked again — sixty-six times in fifty-one
          seconds, measured on a real session. -->
     <link rel="icon" href="/favicon.svg" type="image/svg+xml" />
+    <!-- Installable on a phone (RFC-022 decision 4). The manifest names the
+         icons Android and desktop browsers use; iOS reads its home-screen icon
+         from this tag instead. No service worker: nothing here may be cached
+         past the session, and installing no longer needs one. -->
+    <link rel="manifest" href="/manifest.webmanifest" />
+    <link rel="apple-touch-icon" href="/apple-touch-icon.png" />
+    <meta name="apple-mobile-web-app-title" content="WaveFlow" />
     <title>WaveFlow</title>
     <!-- Inline, and only what the first screen needs. The stylesheet is a
          separate request of about 30 kB, and a splash that waited for it would
diff --git a/webapp/public/apple-touch-icon.png b/webapp/public/apple-touch-icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..50c208e33b14c2157744fdb322afc038b5cc05ea
GIT binary patch
literal 8692
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
Xr-_YmP8#+J56_9?rwlWX*#`UvowXp*

literal 0
HcmV?d00001

diff --git a/webapp/public/icons/icon-192.png b/webapp/public/icons/icon-192.png
new file mode 100644
index 0000000000000000000000000000000000000000..e5dd7e0365dfc7bc1270b2a314808ff259784d92
GIT binary patch
literal 13631
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

literal 0
HcmV?d00001

diff --git a/webapp/public/icons/icon-512.png b/webapp/public/icons/icon-512.png
new file mode 100644
index 0000000000000000000000000000000000000000..b37876671c76cf06f29513eace3b52049ba67f87
GIT binary patch
literal 107787
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
Scfb!E90vN}3wh^nJ^Fv1=wnd;

literal 0
HcmV?d00001

diff --git a/webapp/public/icons/maskable-512.png b/webapp/public/icons/maskable-512.png
new file mode 100644
index 0000000000000000000000000000000000000000..a4232ba25d0148b5c4570167ac516ac26db20120
GIT binary patch
literal 88255
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

literal 0
HcmV?d00001

diff --git a/webapp/public/manifest.webmanifest b/webapp/public/manifest.webmanifest
new file mode 100644
index 00000000..71c11cfb
--- /dev/null
+++ b/webapp/public/manifest.webmanifest
@@ -0,0 +1,31 @@
+{
+  "id": "/",
+  "name": "WaveFlow",
+  "short_name": "WaveFlow",
+  "description": "Your private, self-hosted music library.",
+  "start_url": "/",
+  "scope": "/",
+  "display": "standalone",
+  "background_color": "#101311",
+  "theme_color": "#11100f",
+  "icons": [
+    {
+      "src": "/icons/icon-192.png",
+      "sizes": "192x192",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "/icons/icon-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "/icons/maskable-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "maskable"
+    }
+  ]
+}
diff --git a/webapp/scripts/render-icons.ts b/webapp/scripts/render-icons.ts
new file mode 100644
index 00000000..2017d5ae
--- /dev/null
+++ b/webapp/scripts/render-icons.ts
@@ -0,0 +1,83 @@
+/**
+ * Renders the install icons in `public/` from the one mark (RFC-022 decision 4).
+ *
+ * Run by hand when the mark changes — `node scripts/render-icons.ts` from
+ * `webapp/` — and commit what it writes. Not part of the build: the PNGs are
+ * assets like `favicon.svg`, and a build that needed a browser to produce its
+ * icons would need one on every machine that builds the server.
+ *
+ * The geometry is `logo.svg`'s, never redrawn: five bars, 140/80/40/80/140, in
+ * a 256 box. Two framings:
+ *
+ * - **any**: the favicon's own, `favicon.svg` rendered larger — the rounded
+ *   container in the gradient with the bars cut out of it in the application's
+ *   dark. Its transparent corners are a launcher's to fill.
+ * - **maskable** and the **apple-touch-icon**: full bleed, because a launcher
+ *   or iOS cuts the shape itself, with the bars scaled into the safe zone — the
+ *   central circle of 40% radius that every mask keeps. The bar group's
+ *   corners sit at 45% of the box from its centre, so it is scaled by 0.72 to
+ *   land at about 32%.
+ */
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+import { chromium } from "@playwright/test";
+
+const GRADIENT = `<linearGradient id="g" x1="0" y1="0" x2="256" y2="256" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#34D399"/>
+      <stop offset="0.5" stop-color="#10B981"/>
+      <stop offset="1" stop-color="#059669"/>
+    </linearGradient>`;
+
+const BARS = `<rect x="36" y="58" width="24" height="140" rx="12"/>
+    <rect x="76" y="88" width="24" height="80" rx="12"/>
+    <rect x="116" y="108" width="24" height="40" rx="12"/>
+    <rect x="156" y="88" width="24" height="80" rx="12"/>
+    <rect x="196" y="58" width="24" height="140" rx="12"/>`;
+
+function fullBleed(scale: number): string {
+  const offset = 128 * (1 - scale);
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256">
+  <defs>${GRADIENT}</defs>
+  <rect width="256" height="256" fill="url(#g)"/>
+  <g fill="#101311" transform="translate(${offset} ${offset}) scale(${scale})">
+    ${BARS}
+  </g>
+</svg>`;
+}
+
+const favicon = await readFile(
+  new URL("../public/favicon.svg", import.meta.url),
+  "utf8",
+);
+
+const outputs: Array<{ path: string; size: number; svg: string }> = [
+  { path: "../public/icons/icon-192.png", size: 192, svg: favicon },
+  { path: "../public/icons/icon-512.png", size: 512, svg: favicon },
+  { path: "../public/icons/maskable-512.png", size: 512, svg: fullBleed(0.72) },
+  { path: "../public/apple-touch-icon.png", size: 180, svg: fullBleed(0.72) },
+];
+
+const browser = await chromium.launch();
+try {
+  for (const { path, size, svg } of outputs) {
+    const page = await browser.newPage({
+      viewport: { width: size, height: size },
+      deviceScaleFactor: 1,
+    });
+    const source = `data:image/svg+xml;base64,${Buffer.from(svg).toString("base64")}`;
+    await page.setContent(
+      `<html><body style="margin:0;background:transparent"><img src="${source}" width="${size}" height="${size}" style="display:block"></body></html>`,
+    );
+    await page.waitForFunction(() => document.images[0]?.complete === true);
+    const target = new URL(path, import.meta.url);
+    await page.screenshot({
+      path: fileURLToPath(target),
+      omitBackground: true,
+    });
+    await page.close();
+    console.log(`wrote ${path} (${size}px)`);
+  }
+} finally {
+  await browser.close();
+}
diff --git a/webapp/src/api/catalog.ts b/webapp/src/api/catalog.ts
index f2ed2889..e50e75fd 100644
--- a/webapp/src/api/catalog.ts
+++ b/webapp/src/api/catalog.ts
@@ -1,3 +1,4 @@
+import type { ReleaseGroup } from "../lib/discography";
 import { call, collect, request, scoped } from "./client";
 
 export type Album = {
@@ -10,6 +11,11 @@ export type Album = {
   year: number | null;
   starred_at: number | null;
   user_rating: number | null;
+  /**
+   * The discography section the server files the album under (RFC-022
+   * decision 2). Optional so an older server parses; absent reads as an album.
+   */
+  release_group?: ReleaseGroup;
 };
 
 export type Song = {
@@ -47,6 +53,16 @@ export type Song = {
   sample_rate: number | null;
   channels: number | null;
   bit_depth: number | null;
+  /**
+   * ReplayGain as tagged: decibel gains and linear peaks, `null` where the
+   * file carries none. On the wire since `SongItem` gained them; declared here
+   * for the player (RFC-022 decision 1), and optional so a mock that leaves
+   * them out is a track with no tags rather than a type error.
+   */
+  replay_gain_track_gain?: number | null;
+  replay_gain_track_peak?: number | null;
+  replay_gain_album_gain?: number | null;
+  replay_gain_album_peak?: number | null;
 };
 
 export type AlbumDetail = Album & { songs: Song[] };
@@ -102,6 +118,12 @@ export type ArtistDetail = Artist & {
   /** The library the artist belongs to: whose owners may choose its images. */
   library_id: string;
   albums: Album[];
+  /**
+   * Albums a track of which credits the artist, by someone else (RFC-022
+   * decision 3). Present on the artist page only; optional so an older
+   * server parses.
+   */
+  appears_on?: Album[];
   /** Always present on the native page; optional so an older server parses. */
   enrichment?: ArtistEnrichment;
   /** The banner chosen by hand, absent when none was. */
diff --git a/webapp/src/lib/discography.test.ts b/webapp/src/lib/discography.test.ts
new file mode 100644
index 00000000..3a5cc499
--- /dev/null
+++ b/webapp/src/lib/discography.test.ts
@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+
+import { discographySections, type ReleaseGroup } from "./discography";
+
+const album = (title: string, release_group?: ReleaseGroup | null) => ({
+  title,
+  release_group,
+});
+
+const titles = (sections: ReturnType<typeof discographySections>) =>
+  sections.map(({ section, albums }) => [
+    section,
+    albums.map((entry) => (entry as { title: string }).title),
+  ]);
+
+describe("an artist's discography", () => {
+  it("lists its sections in page order, whatever order the albums came in", () => {
+    const sections = discographySections(
+      [
+        album("Greatest", "compilation"),
+        album("Live at Home", "live"),
+        album("Lone", "single"),
+        album("Short", "ep"),
+        album("Long", "album"),
+      ],
+      [album("Guest Spot", "album")],
+    );
+    expect(titles(sections)).toEqual([
+      ["album", ["Long"]],
+      ["ep", ["Short"]],
+      ["single", ["Lone"]],
+      ["live", ["Live at Home"]],
+      ["compilation", ["Greatest"]],
+      ["appearsOn", ["Guest Spot"]],
+    ]);
+  });
+
+  it("keeps the server's order inside a section", () => {
+    const sections = discographySections([
+      album("Second", "album"),
+      album("First", "album"),
+    ]);
+    expect(titles(sections)).toEqual([["album", ["Second", "First"]]]);
+  });
+
+  it("leaves out the sections that hold nothing", () => {
+    expect(titles(discographySections([album("Only", "ep")]))).toEqual([
+      ["ep", ["Only"]],
+    ]);
+    expect(discographySections([], [])).toEqual([]);
+  });
+
+  it("files an album an older server sent without a group as an album", () => {
+    const sections = discographySections([
+      album("Old", undefined),
+      album("Null", null),
+      album("Odd", "bootleg" as ReleaseGroup),
+      // A section name is not a group: only the server's appearances list
+      // fills "Appears on".
+      album("Sly", "appearsOn" as ReleaseGroup),
+    ]);
+    expect(titles(sections)).toEqual([
+      ["album", ["Old", "Null", "Odd", "Sly"]],
+    ]);
+  });
+});
diff --git a/webapp/src/lib/discography.ts b/webapp/src/lib/discography.ts
new file mode 100644
index 00000000..0a329b64
--- /dev/null
+++ b/webapp/src/lib/discography.ts
@@ -0,0 +1,62 @@
+/**
+ * An artist's discography, in the sections the artist page shows
+ * (RFC-022 decisions 2 and 3).
+ *
+ * The server decides which section an album belongs in — `release_group` on
+ * every album — so this only orders the sections and drops the empty ones. It
+ * never reads `release_types` itself: two clients interpreting MusicBrainz's
+ * vocabulary separately is how they come to disagree about the same record.
+ */
+
+export type ReleaseGroup = "album" | "ep" | "single" | "live" | "compilation";
+
+/** A section of the page: one release group, or the albums appeared on. */
+export type DiscographySection = ReleaseGroup | "appearsOn";
+
+/** The order the page lists its sections in. */
+export const SECTION_ORDER: readonly DiscographySection[] = [
+  "album",
+  "ep",
+  "single",
+  "live",
+  "compilation",
+  "appearsOn",
+];
+
+const GROUPS = new Set<string>([
+  "album",
+  "ep",
+  "single",
+  "live",
+  "compilation",
+] satisfies ReleaseGroup[]);
+
+/**
+ * The albums of an artist page, sectioned, in page order, empty sections left
+ * out. Each section keeps the order the server sent, which is year then title.
+ *
+ * An album with no `release_group` — sent by a server older than RFC-022 — is
+ * an album, which is what the page showed for it before.
+ */
+export function discographySections<
+  T extends { release_group?: ReleaseGroup | null },
+>(
+  albums: readonly T[],
+  appearsOn: readonly T[] = [],
+): Array<{ section: DiscographySection; albums: T[] }> {
+  const sections = new Map<DiscographySection, T[]>();
+  for (const album of albums) {
+    const group =
+      album.release_group && GROUPS.has(album.release_group)
+        ? album.release_group
+        : "album";
+    const list = sections.get(group) ?? [];
+    list.push(album);
+    sections.set(group, list);
+  }
+  if (appearsOn.length > 0) sections.set("appearsOn", [...appearsOn]);
+  return SECTION_ORDER.flatMap((section) => {
+    const list = sections.get(section);
+    return list && list.length > 0 ? [{ section, albums: list }] : [];
+  });
+}
diff --git a/webapp/src/lib/replay-gain.test.ts b/webapp/src/lib/replay-gain.test.ts
new file mode 100644
index 00000000..8db05c3d
--- /dev/null
+++ b/webapp/src/lib/replay-gain.test.ts
@@ -0,0 +1,136 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  clampPreamp,
+  DEFAULT_REPLAY_GAIN,
+  parseReplayGainPreference,
+  type ReplayGainPreference,
+  replayGainFactor,
+  routableThroughWebAudio,
+} from "./replay-gain";
+
+const decibels = (factor: number) => 20 * Math.log10(factor);
+
+const tagged = {
+  replay_gain_track_gain: -7.5,
+  replay_gain_track_peak: 0.5,
+  replay_gain_album_gain: -6,
+  replay_gain_album_peak: 0.25,
+};
+
+const mode = (
+  value: ReplayGainPreference["mode"],
+  preampDb = 0,
+): ReplayGainPreference => ({ mode: value, preampDb });
+
+describe("the gain a track is played at", () => {
+  it("is unity while ReplayGain is off, whatever the tags say", () => {
+    expect(replayGainFactor(tagged, mode("off", 6))).toBe(1);
+  });
+
+  it("follows the track gain in track mode and the album gain in album mode", () => {
+    expect(decibels(replayGainFactor(tagged, mode("track")))).toBeCloseTo(-7.5);
+    expect(decibels(replayGainFactor(tagged, mode("album")))).toBeCloseTo(-6);
+  });
+
+  it("falls back to the other pair when the chosen gain is missing", () => {
+    const trackOnly = { ...tagged, replay_gain_album_gain: null };
+    expect(decibels(replayGainFactor(trackOnly, mode("album")))).toBeCloseTo(
+      -7.5,
+    );
+    const albumOnly = { ...tagged, replay_gain_track_gain: undefined };
+    expect(decibels(replayGainFactor(albumOnly, mode("track")))).toBeCloseTo(
+      -6,
+    );
+  });
+
+  it("plays an untagged track at unity, and does not preamp it", () => {
+    expect(replayGainFactor({}, mode("album", 6))).toBe(1);
+    expect(
+      replayGainFactor(
+        { replay_gain_track_gain: Number.NaN, replay_gain_track_peak: 0.5 },
+        mode("track", 6),
+      ),
+    ).toBe(1);
+  });
+
+  it("adds the preamp to a tagged track", () => {
+    expect(decibels(replayGainFactor(tagged, mode("track", 3)))).toBeCloseTo(
+      -4.5,
+    );
+  });
+
+  it("never raises a track past the point its peak would clip", () => {
+    // +6 dB on a peak of 0.8 would reach 1.6; the cap holds it at 1 / 0.8.
+    const quiet = { replay_gain_track_gain: 6, replay_gain_track_peak: 0.8 };
+    expect(replayGainFactor(quiet, mode("track"))).toBeCloseTo(1.25);
+    // The peak checked is the one paired with the gain used: the album peak
+    // of 0.25 allows up to 4x, so −6 dB plus a 12 dB preamp passes uncapped.
+    expect(decibels(replayGainFactor(tagged, mode("album", 12)))).toBeCloseTo(
+      6,
+    );
+  });
+
+  it("ignores a peak that is not a measurement", () => {
+    const broken = { replay_gain_track_gain: 6, replay_gain_track_peak: 0 };
+    expect(decibels(replayGainFactor(broken, mode("track")))).toBeCloseTo(6);
+  });
+
+  it("bounds an absurd tag rather than following it", () => {
+    const loud = { replay_gain_track_gain: 80 };
+    expect(decibels(replayGainFactor(loud, mode("track")))).toBeCloseTo(18);
+    const silent = { replay_gain_track_gain: -500 };
+    expect(decibels(replayGainFactor(silent, mode("track")))).toBeCloseTo(-60);
+  });
+});
+
+describe("the stored preference", () => {
+  it("is the default when nothing, or nothing readable, was stored", () => {
+    expect(parseReplayGainPreference(null)).toEqual(DEFAULT_REPLAY_GAIN);
+    expect(parseReplayGainPreference("not json")).toEqual(DEFAULT_REPLAY_GAIN);
+    expect(parseReplayGainPreference("42")).toEqual(DEFAULT_REPLAY_GAIN);
+    expect(DEFAULT_REPLAY_GAIN.mode).toBe("off");
+  });
+
+  it("reads back what was written", () => {
+    expect(
+      parseReplayGainPreference(
+        JSON.stringify({ mode: "album", preampDb: -3 }),
+      ),
+    ).toEqual({ mode: "album", preampDb: -3 });
+  });
+
+  it("keeps a valid mode beside a preamp out of range, clamped", () => {
+    expect(
+      parseReplayGainPreference(
+        JSON.stringify({ mode: "track", preampDb: 20 }),
+      ),
+    ).toEqual({ mode: "track", preampDb: 12 });
+    expect(
+      parseReplayGainPreference(JSON.stringify({ mode: "loud", preampDb: 2 })),
+    ).toEqual({ mode: "off", preampDb: 2 });
+  });
+
+  it("rounds a preamp to whole decibels", () => {
+    expect(clampPreamp(2.6)).toBe(3);
+    expect(clampPreamp(-13)).toBe(-12);
+    expect(clampPreamp(Number.POSITIVE_INFINITY)).toBe(0);
+  });
+});
+
+describe("which media may be routed through Web Audio", () => {
+  const page = "https://music.example.com/albums/1";
+
+  it("accepts a stream ticket, which is a relative URL", () => {
+    expect(routableThroughWebAudio("/api/v2/stream/abc", page)).toBe(true);
+  });
+
+  it("refuses media on another origin, which would play as silence", () => {
+    expect(routableThroughWebAudio("https://cdn.example.net/a.mp3", page)).toBe(
+      false,
+    );
+    expect(routableThroughWebAudio("http://music.example.com/a", page)).toBe(
+      false,
+    );
+  });
+});
diff --git a/webapp/src/lib/replay-gain.ts b/webapp/src/lib/replay-gain.ts
new file mode 100644
index 00000000..447dc212
--- /dev/null
+++ b/webapp/src/lib/replay-gain.ts
@@ -0,0 +1,147 @@
+/**
+ * ReplayGain, as the web player applies it (RFC-022 decision 1).
+ *
+ * No React here: what the player needs is a number to put on a `GainNode`, and
+ * the rules that produce it are the part worth testing on their own.
+ */
+
+export type ReplayGainMode = "off" | "track" | "album";
+
+export const REPLAY_GAIN_MODES: readonly ReplayGainMode[] = [
+  "off",
+  "track",
+  "album",
+];
+
+export type ReplayGainPreference = {
+  mode: ReplayGainMode;
+  /** Added to a tagged track's gain, in whole decibels. */
+  preampDb: number;
+};
+
+/** The four values the scanner stores, as `SongItem` carries them. */
+export type ReplayGainTags = {
+  replay_gain_track_gain?: number | null;
+  replay_gain_track_peak?: number | null;
+  replay_gain_album_gain?: number | null;
+  replay_gain_album_peak?: number | null;
+};
+
+export const PREAMP_MIN_DB = -12;
+export const PREAMP_MAX_DB = 12;
+
+/**
+ * Bounds on the total, against a tag that is simply wrong. A gain of +40 dB is
+ * not a loudness preference, it is a corrupt file about to deafen someone.
+ */
+const TOTAL_MIN_DB = -60;
+const TOTAL_MAX_DB = 18;
+
+export const DEFAULT_REPLAY_GAIN: ReplayGainPreference = {
+  // Off until asked for: turning it on routes the element through an
+  // AudioContext, which some mobile browsers suspend with the page.
+  mode: "off",
+  preampDb: 0,
+};
+
+function finite(value: number | null | undefined): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+/** A peak is a linear sample amplitude; zero or less is not a measurement. */
+function usablePeak(value: number | null | undefined): number | null {
+  return finite(value) && value > 0 ? value : null;
+}
+
+/**
+ * The linear gain to apply to a track, 1 meaning unchanged.
+ *
+ * - `album` takes the album gain and peak, and falls back to the track's pair
+ *   when the album gain is missing; `track` does the reverse. An album
+ *   normalisation is still closer than none.
+ * - A track with neither plays at unity, **without** the preamp: the preamp
+ *   raises normalised tracks toward untouched ones, and adding it to an
+ *   untouched track would undo exactly that.
+ * - When the peak paired with the chosen gain is known, the result is capped at
+ *   `1 / peak`, so a raised track never clips.
+ */
+export function replayGainFactor(
+  tags: ReplayGainTags,
+  preference: ReplayGainPreference,
+): number {
+  if (preference.mode === "off") return 1;
+  const track = {
+    gain: tags.replay_gain_track_gain,
+    peak: tags.replay_gain_track_peak,
+  };
+  const album = {
+    gain: tags.replay_gain_album_gain,
+    peak: tags.replay_gain_album_peak,
+  };
+  const [first, second] =
+    preference.mode === "album" ? [album, track] : [track, album];
+  const chosen = finite(first.gain)
+    ? first
+    : finite(second.gain)
+      ? second
+      : null;
+  if (!chosen || !finite(chosen.gain)) return 1;
+  const preamp = finite(preference.preampDb) ? preference.preampDb : 0;
+  const decibels = Math.min(
+    TOTAL_MAX_DB,
+    Math.max(TOTAL_MIN_DB, chosen.gain + preamp),
+  );
+  const linear = 10 ** (decibels / 20);
+  const peak = usablePeak(chosen.peak);
+  return peak === null ? linear : Math.min(linear, 1 / peak);
+}
+
+/**
+ * The stored preference, or the default for anything that is not one.
+ *
+ * Read back from `localStorage`, which a person, an extension or an older
+ * build may have written anything into. A mode it does not know is `off`, and
+ * a preamp out of range is clamped rather than refused, so a stored +20 from a
+ * hand edit lands on +12 instead of losing the mode beside it.
+ */
+export function parseReplayGainPreference(
+  raw: string | null,
+): ReplayGainPreference {
+  if (raw === null) return DEFAULT_REPLAY_GAIN;
+  let value: unknown;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return DEFAULT_REPLAY_GAIN;
+  }
+  if (typeof value !== "object" || value === null) return DEFAULT_REPLAY_GAIN;
+  const { mode, preampDb } = value as Record<string, unknown>;
+  return {
+    mode: REPLAY_GAIN_MODES.includes(mode as ReplayGainMode)
+      ? (mode as ReplayGainMode)
+      : "off",
+    preampDb: clampPreamp(typeof preampDb === "number" ? preampDb : 0),
+  };
+}
+
+/** A preamp in whole decibels, inside the range the control offers. */
+export function clampPreamp(value: number): number {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(PREAMP_MAX_DB, Math.max(PREAMP_MIN_DB, Math.round(value)));
+}
+
+/**
+ * Whether a media URL may be routed through Web Audio.
+ *
+ * `createMediaElementSource` outputs silence for cross-origin media served
+ * without CORS. Stream tickets are relative, so they are same-origin by
+ * construction; this is the check that keeps a future absolute URL from
+ * turning ReplayGain into a mute button.
+ */
+export function routableThroughWebAudio(url: string, page: string): boolean {
+  try {
+    return new URL(url, page).origin === new URL(page).origin;
+  } catch {
+    return false;
+  }
+}
diff --git a/webapp/src/pages/artist-page.tsx b/webapp/src/pages/artist-page.tsx
index cee57c27..9cdd7049 100644
--- a/webapp/src/pages/artist-page.tsx
+++ b/webapp/src/pages/artist-page.tsx
@@ -1,7 +1,7 @@
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { Link } from "@tanstack/react-router";
 
-import type { ArtistEnrichment } from "../api";
+import type { Album, ArtistEnrichment } from "../api";
 import {
   artistQuery,
   artistTopSongsQuery,
@@ -14,7 +14,11 @@ import { Artwork } from "../components/artwork";
 import { Loading } from "../components/page-shell";
 import { SongTable } from "../components/song-table";
 import { isSplitCandidate } from "../lib/credit-fragments";
-import { useI18n } from "../state/i18n";
+import {
+  type DiscographySection,
+  discographySections,
+} from "../lib/discography";
+import { type TranslationKey, useI18n } from "../state/i18n";
 import { mayCorrectTracks, useLibraryScope } from "../state/library-scope";
 
 /** A provider as a reader knows it, rather than as the setting spells it. */
@@ -209,7 +213,48 @@ export function ArtistPage({ artistId }: { artistId: string }) {
           <SongTable songs={played} />
         </section>
       ) : null}
-      <AlbumGrid albums={value.albums} />
+      <ArtistDiscography albums={value.albums} appearsOn={value.appears_on} />
     </section>
   );
 }
+
+const SECTION_TITLES: Record<DiscographySection, TranslationKey> = {
+  album: "artists.section.album",
+  ep: "artists.section.ep",
+  single: "artists.section.single",
+  live: "artists.section.live",
+  compilation: "artists.section.compilation",
+  appearsOn: "artists.section.appearsOn",
+};
+
+/**
+ * The albums, in the sections the server filed them under (RFC-022): Albums,
+ * EPs, Singles, Live, Compilations, then what the artist appears on. A section
+ * with nothing in it is left out rather than drawn empty, and an artist with
+ * nothing at all keeps the grid's own "no albums" line.
+ */
+function ArtistDiscography({
+  albums,
+  appearsOn,
+}: {
+  albums: Album[];
+  appearsOn: Album[] | undefined;
+}) {
+  const { t } = useI18n();
+  const sections = discographySections(albums, appearsOn ?? []);
+  if (sections.length === 0) return <AlbumGrid albums={[]} />;
+  return (
+    <>
+      {sections.map(({ section, albums: listed }) => (
+        <section
+          key={section}
+          className="artist-discography"
+          aria-labelledby={`discography-${section}`}
+        >
+          <h3 id={`discography-${section}`}>{t(SECTION_TITLES[section])}</h3>
+          <AlbumGrid albums={listed} />
+        </section>
+      ))}
+    </>
+  );
+}
diff --git a/webapp/src/pages/settings-page.tsx b/webapp/src/pages/settings-page.tsx
index 81492094..58ea4070 100644
--- a/webapp/src/pages/settings-page.tsx
+++ b/webapp/src/pages/settings-page.tsx
@@ -11,7 +11,7 @@ import {
 import { ownApiTokensQuery, ownSubsonicCredentialQuery } from "../api/queries";
 import { Loading, PageHeader, useReload } from "../components/page-shell";
 import { LanguagePicker, type Locale, useI18n } from "../state/i18n";
-import { ThemePicker } from "../state/preferences";
+import { ReplayGainPicker, ThemePicker } from "../state/preferences";
 
 /**
  * Settings, and the clients allowed to read the library.
@@ -365,6 +365,10 @@ export function SettingsPage() {
           <ThemePicker />
           <LanguagePicker />
         </article>
+        <article className="settings-panel">
+          <h3>{t("settings.playback")}</h3>
+          <ReplayGainPicker />
+        </article>
         <article className="settings-panel">
           <h3>{t("nav.scrobbling")}</h3>
           <p className="muted">{t("settings.scrobblingDetail")}</p>
diff --git a/webapp/src/player/player.tsx b/webapp/src/player/player.tsx
index 3bdeb229..0e8ecc34 100644
--- a/webapp/src/player/player.tsx
+++ b/webapp/src/player/player.tsx
@@ -22,7 +22,9 @@ import {
 
 import { Artwork } from "../components/artwork";
 import { Icon } from "../components/icons";
+import { replayGainFactor, routableThroughWebAudio } from "../lib/replay-gain";
 import { useI18n } from "../state/i18n";
+import { useReplayGainPreference } from "../state/preferences";
 
 const VOLUME_KEY = "waveflow.volume";
 
@@ -297,6 +299,56 @@ export function PlayerProvider({ children }: { children: ReactNode }) {
     new Map<string, { url: string; expiresAt: number }>(),
   );
   const preloader = useRef<HTMLAudioElement | null>(null);
+  const replayGain = useReplayGainPreference();
+  const replayGainOn = replayGain.mode !== "off";
+  // The Web Audio graph ReplayGain plays through (RFC-022 decision 1): the
+  // element, one GainNode, the speakers. Built once and never torn down — an
+  // element cannot be detached from its source node — so turning ReplayGain
+  // off afterwards sets the gain to one, and a reload restores the plain path.
+  const graph = useRef<{ context: AudioContext; gain: GainNode } | null>(null);
+  const [gainNode, setGainNode] = useState<GainNode | null>(null);
+
+  /**
+   * Builds the graph if ReplayGain wants it, and wakes it if it sleeps.
+   *
+   * Called from the plays a listener starts, which are always a gesture: a
+   * browser creates a context suspended outside one, and refuses to resume it
+   * there. Never on page load, so a listener who never asked for ReplayGain
+   * keeps the element exactly as it was.
+   */
+  const prepareGraph = useCallback(() => {
+    const element = audio.current;
+    if (!element) return;
+    if (!graph.current && replayGainOn) {
+      // A cross-origin source would play as silence through the graph. The
+      // tickets are relative, so this holds by construction; checked anyway.
+      const source = element.currentSrc || element.src;
+      if (source && !routableThroughWebAudio(source, window.location.href))
+        return;
+      const Context =
+        window.AudioContext ??
+        (window as { webkitAudioContext?: typeof AudioContext })
+          .webkitAudioContext;
+      if (!Context) return;
+      try {
+        const context = new Context();
+        const gain = context.createGain();
+        context
+          .createMediaElementSource(element)
+          .connect(gain)
+          .connect(context.destination);
+        graph.current = { context, gain };
+        setGainNode(gain);
+      } catch {
+        // No graph: the element keeps playing as it did, unlevelled.
+        return;
+      }
+    }
+    const context = graph.current?.context;
+    if (context && context.state !== "running") {
+      void context.resume().catch(() => undefined);
+    }
+  }, [replayGainOn]);
 
   const current = queue[index] ?? null;
   orderRef.current =
@@ -503,24 +555,30 @@ export function PlayerProvider({ children }: { children: ReactNode }) {
     }
   }, [position, duration, current]);
 
-  const play = useCallback((next: Song[], at: number) => {
-    localMutation.current = true;
-    const sameSelection = next === queueRef.current && at === indexRef.current;
-    if (sameSelection) {
-      const element = audio.current;
-      const selected = next[at];
-      if (element && selected) {
-        void element
-          .play()
-          .then(() => scrobble(selected.id, false))
-          .catch(() => undefined);
+  const play = useCallback(
+    (next: Song[], at: number) => {
+      // First, inside the gesture that asked for the music.
+      prepareGraph();
+      localMutation.current = true;
+      const sameSelection =
+        next === queueRef.current && at === indexRef.current;
+      if (sameSelection) {
+        const element = audio.current;
+        const selected = next[at];
+        if (element && selected) {
+          void element
+            .play()
+            .then(() => scrobble(selected.id, false))
+            .catch(() => undefined);
+        }
+        return;
       }
-      return;
-    }
-    autoplay.current = true;
-    setQueue(next);
-    setIndex(at);
-  }, []);
+      autoplay.current = true;
+      setQueue(next);
+      setIndex(at);
+    },
+    [prepareGraph],
+  );
 
   useEffect(() => {
     if (!hydrated || !localMutation.current) return;
@@ -537,11 +595,27 @@ export function PlayerProvider({ children }: { children: ReactNode }) {
   const startPlayback = useCallback(() => {
     const element = audio.current;
     if (!element || !current || !element.paused) return;
+    prepareGraph();
     void element
       .play()
       .then(() => scrobble(current.id, false))
       .catch(() => undefined);
-  }, [current]);
+  }, [current, prepareGraph]);
+
+  // Turned on mid-track: the change came from the settings control, which is
+  // a gesture, so the graph can be built while the browser still counts it as
+  // one. Paused, it waits for the next play instead.
+  useEffect(() => {
+    if (replayGainOn && audio.current && !audio.current.paused) prepareGraph();
+  }, [replayGainOn, prepareGraph]);
+
+  // The level of the track now playing. Set when the track changes, before
+  // its first sample, and again when the preference does; off is a gain of 1.
+  useEffect(() => {
+    if (!gainNode) return;
+    const factor = current ? replayGainFactor(current, replayGain) : 1;
+    gainNode.gain.setValueAtTime(factor, gainNode.context.currentTime);
+  }, [gainNode, current, replayGain]);
 
   const pausePlayback = useCallback(() => {
     const element = audio.current;
@@ -615,7 +689,9 @@ export function PlayerProvider({ children }: { children: ReactNode }) {
     else pausePlayback();
   }, [pausePlayback, startPlayback]);
 
+  // Both are pressed, so both are a gesture the graph can be built in.
   const next = useCallback(() => {
+    prepareGraph();
     localMutation.current = true;
     setIndex((value) => {
       // Pressed, not ended: `repeat: "one"` must not trap the button here.
@@ -624,9 +700,10 @@ export function PlayerProvider({ children }: { children: ReactNode }) {
       autoplay.current = target !== value;
       return target;
     });
-  }, []);
+  }, [prepareGraph]);
 
   const previous = useCallback(() => {
+    prepareGraph();
     localMutation.current = true;
     setIndex((value) => {
       const target = retreat(orderRef.current, value, repeatRef.current);
@@ -634,7 +711,7 @@ export function PlayerProvider({ children }: { children: ReactNode }) {
       autoplay.current = target !== value;
       return target;
     });
-  }, []);
+  }, [prepareGraph]);
 
   const seek = useCallback(
     (seconds: number) => {
diff --git a/webapp/src/state/i18n.tsx b/webapp/src/state/i18n.tsx
index ac083b6c..e97a6fab 100644
--- a/webapp/src/state/i18n.tsx
+++ b/webapp/src/state/i18n.tsx
@@ -30,6 +30,13 @@ const en = {
   "nav.moreClose": "Close",
   "preferences.theme": "Theme",
   "preferences.language": "Language",
+  "replayGain.label": "ReplayGain",
+  "replayGain.off": "Off",
+  "replayGain.track": "Track gain",
+  "replayGain.album": "Album gain",
+  "replayGain.preamp": "Preamp",
+  "replayGain.detail":
+    "Plays every track at the loudness its tags measured, so one record is not louder than the next. Album gain keeps the differences inside an album. A track without tags plays as it is. It routes playback through Web Audio, which some phones pause with the screen.",
   "common.loading": "Loading",
   "common.loadError": "We could not load this view",
   "common.noAlbums": "No albums yet.",
@@ -68,6 +75,7 @@ const en = {
   "settings.detail":
     "Appearance, language, and the clients allowed to read your library.",
   "settings.appearance": "Appearance",
+  "settings.playback": "Playback",
   "settings.scrobblingDetail":
     "Send what you listen to to ListenBrainz, Last.fm or Maloja.",
   "settings.scrobblingOpen": "Open scrobbling settings",
@@ -263,6 +271,12 @@ const en = {
     other: "{count} albums in your library",
   },
   "artists.mostPlayed": "Most played here",
+  "artists.section.album": "Albums",
+  "artists.section.ep": "EPs",
+  "artists.section.single": "Singles",
+  "artists.section.live": "Live",
+  "artists.section.compilation": "Compilations",
+  "artists.section.appearsOn": "Appears on",
   "artists.about": "About",
   "artists.readMore": "Read more",
   "artists.similar": "Similar artists in your library",
@@ -861,6 +875,13 @@ const fr: Record<TranslationKey, TranslationValue> = {
   "nav.moreClose": "Fermer",
   "preferences.theme": "Thème",
   "preferences.language": "Langue",
+  "replayGain.label": "ReplayGain",
+  "replayGain.off": "Désactivé",
+  "replayGain.track": "Gain par piste",
+  "replayGain.album": "Gain par album",
+  "replayGain.preamp": "Préampli",
+  "replayGain.detail":
+    "Joue chaque piste au volume mesuré dans ses tags, pour qu’un disque ne sonne pas plus fort que le suivant. Le gain par album garde les écarts à l’intérieur d’un album. Une piste sans tags est jouée telle quelle. La lecture passe alors par Web Audio, que certains téléphones mettent en pause avec l’écran.",
   "common.loading": "Chargement",
   "common.loadError": "Impossible de charger cette vue",
   "common.noAlbums": "Aucun album pour le moment.",
@@ -899,6 +920,7 @@ const fr: Record<TranslationKey, TranslationValue> = {
   "settings.detail":
     "Apparence, langue, et les clients autorisés à lire votre bibliothèque.",
   "settings.appearance": "Apparence",
+  "settings.playback": "Lecture",
   "settings.scrobblingDetail":
     "Envoyer ce que vous écoutez vers ListenBrainz, Last.fm ou Maloja.",
   "settings.scrobblingOpen": "Ouvrir les réglages de scrobbling",
@@ -1099,6 +1121,12 @@ const fr: Record<TranslationKey, TranslationValue> = {
     other: "{count} albums dans votre bibliothèque",
   },
   "artists.mostPlayed": "Les plus écoutés ici",
+  "artists.section.album": "Albums",
+  "artists.section.ep": "EP",
+  "artists.section.single": "Singles",
+  "artists.section.live": "Live",
+  "artists.section.compilation": "Compilations",
+  "artists.section.appearsOn": "Apparaît sur",
   "artists.about": "À propos",
   "artists.readMore": "Lire la suite",
   "artists.similar": "Artistes proches dans votre bibliothèque",
diff --git a/webapp/src/state/preferences.tsx b/webapp/src/state/preferences.tsx
index f3fe6561..74a3df04 100644
--- a/webapp/src/state/preferences.tsx
+++ b/webapp/src/state/preferences.tsx
@@ -4,9 +4,18 @@ import {
   useCallback,
   useContext,
   useEffect,
+  useId,
   useState,
 } from "react";
-
+import {
+  clampPreamp,
+  PREAMP_MAX_DB,
+  PREAMP_MIN_DB,
+  parseReplayGainPreference,
+  REPLAY_GAIN_MODES,
+  type ReplayGainMode,
+  type ReplayGainPreference,
+} from "../lib/replay-gain";
 import {
   applyTheme,
   findTheme,
@@ -16,14 +25,30 @@ import {
 import { type TranslationKey, useI18n } from "./i18n";
 
 const STORAGE_KEY = "waveflow.theme";
+/**
+ * Per browser, like the volume and the theme: how loud a device should be is
+ * not a property of the account (RFC-022 decision 1).
+ */
+const REPLAY_GAIN_KEY = "waveflow.replayGain";
 
 type Preferences = {
   themeId: string;
   setThemeId: (id: string) => void;
+  replayGain: ReplayGainPreference;
+  setReplayGain: (preference: ReplayGainPreference) => void;
 };
 
 const PreferencesContext = createContext<Preferences | null>(null);
 
+function readStoredReplayGain(): ReplayGainPreference {
+  try {
+    return parseReplayGainPreference(localStorage.getItem(REPLAY_GAIN_KEY));
+  } catch {
+    // Blocked site data: the default, which is off.
+    return parseReplayGainPreference(null);
+  }
+}
+
 export function PreferencesProvider({ children }: { children: ReactNode }) {
   const [themeId, setStoredThemeId] = useState(() => {
     let theme: ThemePreset;
@@ -35,6 +60,7 @@ export function PreferencesProvider({ children }: { children: ReactNode }) {
     applyTheme(theme);
     return theme.id;
   });
+  const [replayGain, setReplayGainState] = useState(readStoredReplayGain);
 
   useEffect(() => {
     try {
@@ -44,19 +70,44 @@ export function PreferencesProvider({ children }: { children: ReactNode }) {
     }
   }, [themeId]);
 
+  useEffect(() => {
+    try {
+      localStorage.setItem(REPLAY_GAIN_KEY, JSON.stringify(replayGain));
+    } catch {
+      // The level still applies for this session without persistence.
+    }
+  }, [replayGain]);
+
   const setThemeId = useCallback((id: string) => {
     const theme = findTheme(id);
     applyTheme(theme);
     setStoredThemeId(theme.id);
   }, []);
 
+  const setReplayGain = useCallback((preference: ReplayGainPreference) => {
+    setReplayGainState({
+      mode: preference.mode,
+      preampDb: clampPreamp(preference.preampDb),
+    });
+  }, []);
+
   return (
-    <PreferencesContext.Provider value={{ themeId, setThemeId }}>
+    <PreferencesContext.Provider
+      value={{ themeId, setThemeId, replayGain, setReplayGain }}
+    >
       {children}
     </PreferencesContext.Provider>
   );
 }
 
+/** The ReplayGain preference, for the player that applies it. */
+export function useReplayGainPreference(): ReplayGainPreference {
+  const preferences = useContext(PreferencesContext);
+  if (!preferences)
+    throw new Error("useReplayGainPreference requires PreferencesProvider");
+  return preferences.replayGain;
+}
+
 export function ThemePicker() {
   const preferences = useContext(PreferencesContext);
   const { t } = useI18n();
@@ -78,3 +129,81 @@ export function ThemePicker() {
     </label>
   );
 }
+
+const MODE_LABELS: Record<ReplayGainMode, TranslationKey> = {
+  off: "replayGain.off",
+  track: "replayGain.track",
+  album: "replayGain.album",
+};
+
+/** A preamp as a reader writes it: signed, in decibels. */
+function formatPreamp(decibels: number): string {
+  return `${decibels > 0 ? "+" : decibels < 0 ? "−" : "±"}${Math.abs(decibels)} dB`;
+}
+
+/**
+ * ReplayGain: whether, and by which measurement, tracks are levelled.
+ *
+ * The preamp is offered only while a mode is on, since it changes nothing
+ * otherwise. Off by default; the note says what turning it on costs, because
+ * routing playback through Web Audio is not free on every phone.
+ */
+export function ReplayGainPicker() {
+  const preferences = useContext(PreferencesContext);
+  const { t } = useI18n();
+  const preampId = useId();
+  if (!preferences)
+    throw new Error("ReplayGainPicker requires PreferencesProvider");
+  const { replayGain, setReplayGain } = preferences;
+  return (
+    <div className="replay-gain-picker">
+      <label className="theme-picker">
+        <span>{t("replayGain.label")}</span>
+        <select
+          aria-label={t("replayGain.label")}
+          value={replayGain.mode}
+          onChange={(event) =>
+            setReplayGain({
+              ...replayGain,
+              mode: event.target.value as ReplayGainMode,
+            })
+          }
+        >
+          {REPLAY_GAIN_MODES.map((mode) => (
+            <option key={mode} value={mode}>
+              {t(MODE_LABELS[mode])}
+            </option>
+          ))}
+        </select>
+      </label>
+      {replayGain.mode !== "off" ? (
+        <div className="replay-gain-preamp">
+          {/* The reading sits beside the label rather than inside it: inside,
+              it would become part of the slider's accessible name. */}
+          <div className="replay-gain-preamp-heading">
+            <label htmlFor={preampId}>{t("replayGain.preamp")}</label>
+            <output htmlFor={preampId}>
+              {formatPreamp(replayGain.preampDb)}
+            </output>
+          </div>
+          <input
+            id={preampId}
+            type="range"
+            aria-valuetext={formatPreamp(replayGain.preampDb)}
+            min={PREAMP_MIN_DB}
+            max={PREAMP_MAX_DB}
+            step={1}
+            value={replayGain.preampDb}
+            onChange={(event) =>
+              setReplayGain({
+                ...replayGain,
+                preampDb: Number(event.target.value),
+              })
+            }
+          />
+        </div>
+      ) : null}
+      <p className="muted">{t("replayGain.detail")}</p>
+    </div>
+  );
+}
diff --git a/webapp/src/styles/fluid.css b/webapp/src/styles/fluid.css
index 8b94182a..88b6575f 100644
--- a/webapp/src/styles/fluid.css
+++ b/webapp/src/styles/fluid.css
@@ -276,6 +276,7 @@
   .page-heading h2,
   .album-related h3,
   .artist-played h3,
+  .artist-discography h3,
   .artist-similar h3
 )::after {
   display: block;
diff --git a/webapp/src/styles/refresh.css b/webapp/src/styles/refresh.css
index bfe1df1b..ce78c2d7 100644
--- a/webapp/src/styles/refresh.css
+++ b/webapp/src/styles/refresh.css
@@ -497,6 +497,41 @@ main > section {
   max-width: 25rem;
 }
 
+/* ReplayGain (RFC-022): the mode is a picker like the theme; the preamp is a
+   slider beside it, labelled like the pickers so the panel reads as one form,
+   with its value in ordinary case — "+3 dB", not "+3 DB". */
+.replay-gain-picker {
+  display: grid;
+  gap: var(--space-3);
+}
+
+.replay-gain-preamp {
+  display: grid;
+  max-width: 25rem;
+  gap: var(--space-1);
+}
+
+.replay-gain-preamp-heading {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: var(--space-3);
+}
+
+.replay-gain-preamp-heading label {
+  color: var(--muted);
+  font-size: var(--text-xs);
+  font-weight: 700;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+}
+
+.replay-gain-preamp-heading output {
+  color: var(--muted);
+  font-size: var(--text-xs);
+  font-variant-numeric: tabular-nums;
+}
+
 .settings-page .settings-panel > a {
   justify-self: start;
   color: var(--accent);
diff --git a/webapp/src/styles/styles.css b/webapp/src/styles/styles.css
index 9d88c91e..c6d39c7e 100644
--- a/webapp/src/styles/styles.css
+++ b/webapp/src/styles/styles.css
@@ -1009,6 +1009,7 @@ main {
 }
 
 .artist-about,
+.artist-discography,
 .artist-similar {
   display: grid;
   gap: var(--space-3);
@@ -1016,6 +1017,7 @@ main {
 }
 
 .artist-about h3,
+.artist-discography h3,
 .artist-similar h3 {
   margin: 0;
   font-size: var(--text-xl);

From a9946294ca899307360d88eb31e5856a85ee79fd Mon Sep 17 00:00:00 2001
From: InstaZDLL <github.105mh@8shield.net>
Date: Sun, 25 Oct 2026 02:57:02 +0200
Subject: [PATCH 4/8] docs: RFC-022 names #326 in its Implemented by line

Signed-off-by: InstaZDLL <github.105mh@8shield.net>
---
 docs/rfcs/RFC-022-playback-and-web-client.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/rfcs/RFC-022-playback-and-web-client.md b/docs/rfcs/RFC-022-playback-and-web-client.md
index 37d0f58a..0f266667 100644
--- a/docs/rfcs/RFC-022-playback-and-web-client.md
+++ b/docs/rfcs/RFC-022-playback-and-web-client.md
@@ -1,9 +1,9 @@
 # RFC-022 — Playback and the web client: loudness, discography, install, AAC
 
 - **Status**: Proposed
-- **Implemented by**: the pull request that carries this RFC. The *Status*
-  field above never flips in this project; this line is the one that says
-  what is running.
+- **Implemented by**: [#326](https://github.com/InstaZDLL/waveflow-server/pull/326)
+  (this RFC, and all seven decisions with it). The *Status* field above never
+  flips in this project; this line is the one that says what is running.
 - **Date**: 2026-10-25
 - **Authors**: the WaveFlow project
 - **Depends on**: [RFC-002](RFC-002-waveflow-server-v2.md) (the stream tickets,

From 08485ad7007ebdab8e649ecded7c27bcade56d52 Mon Sep 17 00:00:00 2001
From: InstaZDLL <github.105mh@8shield.net>
Date: Sun, 25 Oct 2026 02:21:20 +0100
Subject: [PATCH 5/8] fix(webapp): claim the audio element only once its
 context runs

The ReplayGain graph used to call createMediaElementSource before resuming its context, so a context the browser left suspended would play the music as silence. The context is now resumed first and the element wired only when it runs; otherwise the candidate is closed and the element keeps its direct output, and a later gesture resumes the same candidate rather than making another. Any failure while wiring closes the context. Automatic plays (next track, repeat-one) and a statechange to suspended or interrupted under a playing element ask the graph to run again.

Signed-off-by: InstaZDLL <github.105mh@8shield.net>
---
 webapp/e2e/studio-nocturne.spec.ts |  57 ++++++++++++++++
 webapp/src/lib/audio-graph.test.ts |  89 +++++++++++++++++++++++++
 webapp/src/lib/audio-graph.ts      |  47 ++++++++++++++
 webapp/src/player/player.tsx       | 101 ++++++++++++++++++++---------
 4 files changed, 263 insertions(+), 31 deletions(-)
 create mode 100644 webapp/src/lib/audio-graph.test.ts
 create mode 100644 webapp/src/lib/audio-graph.ts

diff --git a/webapp/e2e/studio-nocturne.spec.ts b/webapp/e2e/studio-nocturne.spec.ts
index 5df9e7e2..ce083f18 100644
--- a/webapp/e2e/studio-nocturne.spec.ts
+++ b/webapp/e2e/studio-nocturne.spec.ts
@@ -6776,3 +6776,60 @@ test("keeps the playback settings and the discography readable in light", async
   ]);
   await expectNoWcagViolations(page);
 });
+
+/**
+ * A context the browser will not let run never claims the element.
+ *
+ * Once `createMediaElementSource` has the element, its sound reaches the
+ * speakers only through the context, so a context left suspended would play
+ * the music as silence while the player said it was playing. Here the
+ * browser's context is replaced by one that stays suspended and whose resume
+ * never settles — what a browser does when it does not count the gesture —
+ * and the element must stay unclaimed, playing as it always did.
+ */
+test("leaves the element alone when the audio context will not run", async ({
+  page,
+}) => {
+  await page.addInitScript(() => {
+    localStorage.setItem(
+      "waveflow.replayGain",
+      JSON.stringify({ mode: "album", preampDb: 0 }),
+    );
+    const record = window as unknown as { __contexts: number; __claims: number };
+    record.__contexts = 0;
+    record.__claims = 0;
+    const Original = window.AudioContext;
+    window.AudioContext = class extends Original {
+      constructor(options?: AudioContextOptions) {
+        super(options);
+        record.__contexts += 1;
+      }
+      override get state(): AudioContextState {
+        return "suspended";
+      }
+      override resume(): Promise<void> {
+        return new Promise(() => undefined);
+      }
+      override createMediaElementSource(element: HTMLMediaElement) {
+        record.__claims += 1;
+        return super.createMediaElementSource(element);
+      }
+    };
+  });
+  await page.goto("/albums/album-2");
+  await page.getByRole("button", { name: "Play album" }).click();
+  await expect(page.locator(".player-track strong")).toHaveText("Hidden Place");
+  await expect
+    .poll(() =>
+      page.evaluate(() => (window as unknown as { __contexts: number }).__contexts),
+    )
+    .toBe(1);
+  // A second gesture asks the same candidate again rather than making another.
+  await page.locator(".album-songs .song-title").nth(1).click();
+  await expect(page.locator(".player-track strong")).toHaveText("Cocoon");
+  const seen = await page.evaluate(() => {
+    const record = window as unknown as { __contexts: number; __claims: number };
+    return { contexts: record.__contexts, claims: record.__claims };
+  });
+  expect(seen).toEqual({ contexts: 1, claims: 0 });
+});
diff --git a/webapp/src/lib/audio-graph.test.ts b/webapp/src/lib/audio-graph.test.ts
new file mode 100644
index 00000000..6b25ca5c
--- /dev/null
+++ b/webapp/src/lib/audio-graph.test.ts
@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+
+import { connectWhenRunning, needsWaking } from "./audio-graph";
+
+/** A context that records what was done to it, and to the graph, in order. */
+function fakeContext(options: {
+  state: string;
+  resumesTo?: string;
+  resumeFails?: boolean;
+}) {
+  const calls: string[] = [];
+  const context = {
+    state: options.state,
+    async resume() {
+      calls.push("resume");
+      if (options.resumeFails) throw new Error("refused");
+      if (options.resumesTo) context.state = options.resumesTo;
+    },
+    async close() {
+      calls.push("close");
+      context.state = "closed";
+    },
+  };
+  /** What the player's wiring does: claim the element, last. */
+  const wire =
+    (fails = false) =>
+    () => {
+      calls.push("createGain");
+      if (fails) throw new Error("already claimed");
+      calls.push("createMediaElementSource");
+      return "graph";
+    };
+  return { context, calls, wire };
+}
+
+describe("wiring the ReplayGain graph", () => {
+  it("wires a running context at once", async () => {
+    const { context, calls, wire } = fakeContext({ state: "running" });
+    expect(await connectWhenRunning(context, wire())).toBe("graph");
+    expect(calls).toEqual(["createGain", "createMediaElementSource"]);
+  });
+
+  it("resumes a suspended context before claiming the element", async () => {
+    const { context, calls, wire } = fakeContext({
+      state: "suspended",
+      resumesTo: "running",
+    });
+    expect(await connectWhenRunning(context, wire())).toBe("graph");
+    expect(calls).toEqual(["resume", "createGain", "createMediaElementSource"]);
+  });
+
+  it("never claims the element for a context that will not run", async () => {
+    // Claimed, the element would play as silence; unclaimed, it plays as it
+    // always did, unlevelled.
+    const { context, calls, wire } = fakeContext({
+      state: "suspended",
+      resumesTo: "suspended",
+    });
+    expect(await connectWhenRunning(context, wire())).toBeNull();
+    expect(calls).toEqual(["resume", "close"]);
+  });
+
+  it("closes the candidate when the resume or the wiring fails", async () => {
+    const refused = fakeContext({ state: "suspended", resumeFails: true });
+    expect(
+      await connectWhenRunning(refused.context, refused.wire()),
+    ).toBeNull();
+    expect(refused.calls).toEqual(["resume", "close"]);
+
+    const broken = fakeContext({ state: "running" });
+    expect(
+      await connectWhenRunning(broken.context, broken.wire(true)),
+    ).toBeNull();
+    expect(broken.calls).toEqual(["createGain", "close"]);
+  });
+});
+
+describe("when a graph is asked to run again", () => {
+  it("is while the element plays and the context has stopped", () => {
+    expect(needsWaking("suspended", false)).toBe(true);
+    expect(needsWaking("interrupted", false)).toBe(true);
+  });
+
+  it("is not while paused, running or closed", () => {
+    expect(needsWaking("suspended", true)).toBe(false);
+    expect(needsWaking("running", false)).toBe(false);
+    expect(needsWaking("closed", false)).toBe(false);
+  });
+});
diff --git a/webapp/src/lib/audio-graph.ts b/webapp/src/lib/audio-graph.ts
new file mode 100644
index 00000000..f3472cba
--- /dev/null
+++ b/webapp/src/lib/audio-graph.ts
@@ -0,0 +1,47 @@
+/**
+ * The order the ReplayGain graph is wired in (RFC-022 decision 1).
+ *
+ * No React here. The order is the whole point, and it is easier to pin with a
+ * fake context than through a player: once `createMediaElementSource` has
+ * claimed an element, the element's sound reaches the speakers only through
+ * the context. A context left suspended — created outside a gesture, or by a
+ * browser that does not count the gesture — would then play the music as
+ * silence while the element reports it playing. So the context is resumed
+ * first, and `wire` (which claims the element) runs only once it runs;
+ * otherwise the candidate is closed and the element keeps its direct output.
+ */
+
+/** What this needs of an `AudioContext`, so a test can supply one. */
+export type ResumableContext = {
+  readonly state: string;
+  resume(): Promise<void>;
+  close(): Promise<void>;
+};
+
+export async function connectWhenRunning<T>(
+  context: ResumableContext,
+  wire: () => T,
+): Promise<T | null> {
+  const abandon = () => {
+    void context.close().catch(() => undefined);
+    return null;
+  };
+  try {
+    if (context.state !== "running") await context.resume();
+    if (context.state !== "running") return abandon();
+    return wire();
+  } catch {
+    // Whatever failed — the resume, the gain, the source — the graph is not
+    // usable; a closed context frees the audio device rather than holding it
+    // for nothing.
+    return abandon();
+  }
+}
+
+/**
+ * Whether a graph's context should be asked to run again: it has stopped
+ * (suspended, or `interrupted` on Safari) while the element is playing.
+ */
+export function needsWaking(state: string, elementPaused: boolean): boolean {
+  return !elementPaused && (state === "suspended" || state === "interrupted");
+}
diff --git a/webapp/src/player/player.tsx b/webapp/src/player/player.tsx
index 0e8ecc34..e6acac75 100644
--- a/webapp/src/player/player.tsx
+++ b/webapp/src/player/player.tsx
@@ -22,6 +22,7 @@ import {
 
 import { Artwork } from "../components/artwork";
 import { Icon } from "../components/icons";
+import { connectWhenRunning, needsWaking } from "../lib/audio-graph";
 import { replayGainFactor, routableThroughWebAudio } from "../lib/replay-gain";
 import { useI18n } from "../state/i18n";
 import { useReplayGainPreference } from "../state/preferences";
@@ -306,49 +307,85 @@ export function PlayerProvider({ children }: { children: ReactNode }) {
   // element cannot be detached from its source node — so turning ReplayGain
   // off afterwards sets the gain to one, and a reload restores the plain path.
   const graph = useRef<{ context: AudioContext; gain: GainNode } | null>(null);
+  // A context created but not yet running, so the element is not yet claimed.
+  // Kept so a later gesture resumes this one rather than making another.
+  const candidate = useRef<AudioContext | null>(null);
   const [gainNode, setGainNode] = useState<GainNode | null>(null);
 
+  /**
+   * Asks a stopped graph to run again. A play that starts by itself — the
+   * next track, repeat-one — is not a gesture, and a browser may refuse; but
+   * Safari's `interrupted` state, after a call or a timer, resumes this way.
+   */
+  const wakeGraph = useCallback(() => {
+    const context = graph.current?.context;
+    if (context && context.state !== "running") {
+      void context.resume().catch(() => undefined);
+    }
+  }, []);
+
   /**
    * Builds the graph if ReplayGain wants it, and wakes it if it sleeps.
    *
    * Called from the plays a listener starts, which are always a gesture: a
    * browser creates a context suspended outside one, and refuses to resume it
    * there. Never on page load, so a listener who never asked for ReplayGain
-   * keeps the element exactly as it was.
+   * keeps the element exactly as it was. The element is claimed only once the
+   * context runs (`connectWhenRunning`): claimed by a suspended context, it
+   * would play as silence.
    */
   const prepareGraph = useCallback(() => {
     const element = audio.current;
     if (!element) return;
-    if (!graph.current && replayGainOn) {
-      // A cross-origin source would play as silence through the graph. The
-      // tickets are relative, so this holds by construction; checked anyway.
-      const source = element.currentSrc || element.src;
-      if (source && !routableThroughWebAudio(source, window.location.href))
-        return;
-      const Context =
-        window.AudioContext ??
-        (window as { webkitAudioContext?: typeof AudioContext })
-          .webkitAudioContext;
-      if (!Context) return;
-      try {
-        const context = new Context();
-        const gain = context.createGain();
-        context
-          .createMediaElementSource(element)
-          .connect(gain)
-          .connect(context.destination);
-        graph.current = { context, gain };
-        setGainNode(gain);
-      } catch {
-        // No graph: the element keeps playing as it did, unlevelled.
-        return;
-      }
+    if (graph.current) {
+      wakeGraph();
+      return;
     }
-    const context = graph.current?.context;
-    if (context && context.state !== "running") {
-      void context.resume().catch(() => undefined);
+    if (!replayGainOn) return;
+    if (candidate.current) {
+      // Still waiting to run: this gesture may be the one it needed.
+      void candidate.current.resume().catch(() => undefined);
+      return;
+    }
+    // A cross-origin source would play as silence through the graph. The
+    // tickets are relative, so this holds by construction; checked anyway.
+    const source = element.currentSrc || element.src;
+    if (source && !routableThroughWebAudio(source, window.location.href))
+      return;
+    const Context =
+      window.AudioContext ??
+      (window as { webkitAudioContext?: typeof AudioContext })
+        .webkitAudioContext;
+    if (!Context) return;
+    let context: AudioContext;
+    try {
+      context = new Context();
+    } catch {
+      return;
     }
-  }, [replayGainOn]);
+    candidate.current = context;
+    void connectWhenRunning(context, () => {
+      const gain = context.createGain();
+      // Last, because it is the step that cannot be undone.
+      context
+        .createMediaElementSource(element)
+        .connect(gain)
+        .connect(context.destination);
+      return gain;
+    }).then((gain) => {
+      if (candidate.current === context) candidate.current = null;
+      // No graph: the element keeps playing as it did, unlevelled.
+      if (!gain) return;
+      graph.current = { context, gain };
+      setGainNode(gain);
+      // Stopped under a playing element — Safari interrupts a context for a
+      // call or a timer — it is asked to run again rather than left silent.
+      context.addEventListener("statechange", () => {
+        if (needsWaking(context.state, audio.current?.paused ?? true))
+          wakeGraph();
+      });
+    });
+  }, [replayGainOn, wakeGraph]);
 
   const current = queue[index] ?? null;
   orderRef.current =
@@ -429,6 +466,7 @@ export function PlayerProvider({ children }: { children: ReactNode }) {
         // would not restart the element. Rewind and play it again by hand.
         element.currentTime = 0;
         submitted.current = null;
+        wakeGraph();
         void element.play().catch(() => undefined);
         return;
       }
@@ -466,7 +504,7 @@ export function PlayerProvider({ children }: { children: ReactNode }) {
       element.removeEventListener("play", onPlay);
       element.removeEventListener("pause", onPause);
     };
-  }, [hydrated, persistQueue]);
+  }, [hydrated, persistQueue, wakeGraph]);
 
   // Loading a track needs a round-trip for its ticket, so guard against a
   // stale response overwriting a newer selection.
@@ -511,6 +549,7 @@ export function PlayerProvider({ children }: { children: ReactNode }) {
           resumeTrack.current = null;
         }
         if (!shouldAutoplay) return;
+        wakeGraph();
         await element.play();
         void scrobble(current.id, false).catch(() => undefined);
       } catch {
@@ -525,7 +564,7 @@ export function PlayerProvider({ children }: { children: ReactNode }) {
       cancelled = true;
       element.removeEventListener("error", onError);
     };
-  }, [current, resolveStream]);
+  }, [current, resolveStream, wakeGraph]);
 
   useEffect(() => {
     const upcoming = queue[index + 1];

From 828f2493b2671df04089dc1254d33813500b7bf2 Mon Sep 17 00:00:00 2001
From: InstaZDLL <github.105mh@8shield.net>
Date: Sun, 25 Oct 2026 02:21:20 +0100
Subject: [PATCH 6/8] test: require the install assets when the built client is
 embedded

The manifest test accepted a JSON 404 for every install asset even with the real client embedded, so a build that dropped an icon passed. It now tells the build from the placeholder by the shell at /, and requires 200 with the right type for the manifest and each icon when the client is built.

Signed-off-by: InstaZDLL <github.105mh@8shield.net>
---
 tests/service.rs | 80 ++++++++++++++++++++++++++++--------------------
 1 file changed, 46 insertions(+), 34 deletions(-)

diff --git a/tests/service.rs b/tests/service.rs
index 46d0fca5..3ad80204 100644
--- a/tests/service.rs
+++ b/tests/service.rs
@@ -213,29 +213,40 @@ async fn probes_and_openapi_are_available_without_scan_readiness() {
 /// The files that make the client installable are served as themselves, or
 /// answered a JSON 404 — never the shell (RFC-022 decision 4).
 ///
-/// Holds whether or not a client build is embedded in the binary under test,
-/// which is what lets it run in both CI jobs: with a build, each file must
-/// arrive with its own type and the manifest must parse; with the placeholder,
-/// each must be a definitive 404. The one answer it can never accept is
+/// Which of the two is required depends on what is embedded, and the test
+/// asks the binary rather than the source tree: `build.rs` embeds the real
+/// client when `webapp/dist` holds one and a placeholder page otherwise, and
+/// the shell at `/` says which. With the real client, every install asset must
+/// be served with its own type — a build that dropped one would not be
+/// installable, and accepting a 404 there would let it pass. With the
+/// placeholder, each must be a definitive JSON 404. Neither may ever be
 /// `text/html`, which is what the router fallback gives any path it does not
 /// know, and which a browser reading a manifest fails on without saying why.
 #[tokio::test]
 async fn the_install_manifest_and_icons_are_never_answered_with_the_shell() {
     let (_temp, config, state) = test_app().await;
     let router = waveflow_server::app(&config, state);
+    let get = |path: &'static str| {
+        let router = router.clone();
+        async move {
+            router
+                .oneshot(Request::get(path).body(Body::empty()).unwrap())
+                .await
+                .unwrap()
+        }
+    };
+    let shell = body_text(get("/").await).await;
+    // The placeholder's own sentence, in `build.rs`.
+    let built = !shell.contains("The web client is not built");
+
     for (path, expected) in [
         ("/manifest.webmanifest", "application/manifest+json"),
         ("/apple-touch-icon.png", "image/png"),
         ("/icons/icon-192.png", "image/png"),
         ("/icons/icon-512.png", "image/png"),
         ("/icons/maskable-512.png", "image/png"),
-        ("/icons/not-shipped.png", "image/png"),
     ] {
-        let response = router
-            .clone()
-            .oneshot(Request::get(path).body(Body::empty()).unwrap())
-            .await
-            .unwrap();
+        let response = get(path).await;
         let status = response.status();
         let kind = response
             .headers()
@@ -243,34 +254,35 @@ async fn the_install_manifest_and_icons_are_never_answered_with_the_shell() {
             .map(|value| value.to_str().unwrap().to_owned())
             .unwrap_or_default();
         assert!(!kind.starts_with("text/html"), "{path} answered the shell");
-        match status {
-            StatusCode::OK => {
-                assert_eq!(kind, expected, "{path}");
-                if path == "/manifest.webmanifest" {
-                    let manifest: serde_json::Value =
-                        serde_json::from_str(&body_text(response).await).unwrap();
-                    assert_eq!(manifest["start_url"], "/");
-                    assert_eq!(manifest["display"], "standalone");
-                    assert!(manifest["icons"].as_array().is_some_and(|icons| icons
-                        .iter()
-                        .any(|icon| icon["purpose"] == "maskable")));
-                }
+        if built {
+            assert_eq!(status, StatusCode::OK, "{path} is missing from the build");
+            assert_eq!(kind, expected, "{path}");
+            if path == "/manifest.webmanifest" {
+                let manifest: serde_json::Value =
+                    serde_json::from_str(&body_text(response).await).unwrap();
+                assert_eq!(manifest["start_url"], "/");
+                assert_eq!(manifest["display"], "standalone");
+                assert!(manifest["icons"]
+                    .as_array()
+                    .is_some_and(|icons| icons.iter().any(|icon| icon["purpose"] == "maskable")));
             }
-            StatusCode::NOT_FOUND => assert!(kind.starts_with("application/json"), "{path}"),
-            other => panic!("{path} answered {other}"),
+        } else {
+            assert_eq!(status, StatusCode::NOT_FOUND, "{path}");
+            assert!(kind.starts_with("application/json"), "{path}");
         }
     }
-    // A name the build never ships is a 404 whatever is embedded.
-    let missing = router
-        .clone()
-        .oneshot(
-            Request::get("/icons/not-shipped.png")
-                .body(Body::empty())
-                .unwrap(),
-        )
-        .await
-        .unwrap();
+
+    // A name no build ships is a JSON 404 whatever is embedded: the case that
+    // still tells the asset-only rule from the fallback when a real client is
+    // embedded and every shipped icon exists.
+    let missing = get("/icons/not-shipped.png").await;
     assert_eq!(missing.status(), StatusCode::NOT_FOUND);
+    assert!(missing
+        .headers()
+        .get("content-type")
+        .map(|value| value.to_str().unwrap().to_owned())
+        .unwrap_or_default()
+        .starts_with("application/json"));
 }
 
 #[tokio::test]

From c6a788259bcd57788adaeb0fca851e152ed739ef Mon Sep 17 00:00:00 2001
From: InstaZDLL <github.105mh@8shield.net>
Date: Sun, 25 Oct 2026 02:21:21 +0100
Subject: [PATCH 7/8] docs(webapp): run the icon script with
 --experimental-strip-types

Node 22.6 to 22.17 do not strip TypeScript types by default, and the repository declares no Node version.

Signed-off-by: InstaZDLL <github.105mh@8shield.net>
---
 webapp/scripts/render-icons.ts | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/webapp/scripts/render-icons.ts b/webapp/scripts/render-icons.ts
index 2017d5ae..86f150ae 100644
--- a/webapp/scripts/render-icons.ts
+++ b/webapp/scripts/render-icons.ts
@@ -1,10 +1,15 @@
 /**
  * Renders the install icons in `public/` from the one mark (RFC-022 decision 4).
  *
- * Run by hand when the mark changes — `node scripts/render-icons.ts` from
- * `webapp/` — and commit what it writes. Not part of the build: the PNGs are
- * assets like `favicon.svg`, and a build that needed a browser to produce its
- * icons would need one on every machine that builds the server.
+ * Run by hand when the mark changes —
+ * `node --experimental-strip-types scripts/render-icons.ts` from `webapp/` —
+ * and commit what it writes. The flag is what lets Node 22.6 to 22.17 read
+ * TypeScript; later versions strip types without it and still accept it. Not
+ * under Bun: Playwright's browser launch hangs there.
+ *
+ * Not part of the build: the PNGs are assets like `favicon.svg`, and a build
+ * that needed a browser to produce its icons would need one on every machine
+ * that builds the server.
  *
  * The geometry is `logo.svg`'s, never redrawn: five bars, 140/80/40/80/140, in
  * a 256 box. Two framings:

From dd762466e10323053a60bd3b95218c4a3a127e06 Mon Sep 17 00:00:00 2001
From: InstaZDLL <github.105mh@8shield.net>
Date: Sun, 25 Oct 2026 02:38:11 +0100
Subject: [PATCH 8/8] fix(webapp): close the player's audio contexts when it
 unmounts

Signing out unmounts the player, and an open AudioContext holds the audio device until it is closed. The candidate and the graph's context are now closed on unmount, and a wiring that finishes after the unmount closes its own context. The mount marker is set on every mount, so StrictMode and Fast Refresh replays keep working, and an element still claimed by a closed context is dropped so a remounted instance makes a fresh one.

Signed-off-by: InstaZDLL <github.105mh@8shield.net>
---
 webapp/e2e/studio-nocturne.spec.ts | 68 ++++++++++++++++++++++++++++++
 webapp/src/player/player.tsx       | 38 +++++++++++++++++
 2 files changed, 106 insertions(+)

diff --git a/webapp/e2e/studio-nocturne.spec.ts b/webapp/e2e/studio-nocturne.spec.ts
index ce083f18..1f54530e 100644
--- a/webapp/e2e/studio-nocturne.spec.ts
+++ b/webapp/e2e/studio-nocturne.spec.ts
@@ -6833,3 +6833,71 @@ test("leaves the element alone when the audio context will not run", async ({
   });
   expect(seen).toEqual({ contexts: 1, claims: 0 });
 });
+
+/**
+ * Signing out closes every AudioContext the player opened.
+ *
+ * Signing out unmounts the player, and an open context holds the audio device
+ * until it is closed; a browser caps how many one page may have, so each
+ * sign-in would otherwise leave one more behind. Both kinds are covered: the
+ * graph a play built, and a candidate still waiting to run — the one a
+ * browser that does not count the gesture leaves pending for ever.
+ */
+for (const kind of ["running", "pending"] as const) {
+  test(`closes the ${kind} audio context when the listener signs out`, async ({
+    page,
+  }, testInfo) => {
+    test.skip(testInfo.project.name !== "desktop", "signs out from the sidebar");
+    await page.addInitScript((pending) => {
+      localStorage.setItem(
+        "waveflow.replayGain",
+        JSON.stringify({ mode: "album", preampDb: 0 }),
+      );
+      const contexts: AudioContext[] = [];
+      (window as unknown as { __contexts: AudioContext[] }).__contexts =
+        contexts;
+      const Original = window.AudioContext;
+      window.AudioContext = pending
+        ? class extends Original {
+            constructor(options?: AudioContextOptions) {
+              super(options);
+              contexts.push(this);
+            }
+            // Stays suspended until closed, and never resumes.
+            override get state(): AudioContextState {
+              return super.state === "closed" ? "closed" : "suspended";
+            }
+            override resume(): Promise<void> {
+              return new Promise(() => undefined);
+            }
+          }
+        : class extends Original {
+            constructor(options?: AudioContextOptions) {
+              super(options);
+              contexts.push(this);
+            }
+          };
+    }, kind === "pending");
+    const states = () =>
+      page.evaluate(() =>
+        (window as unknown as { __contexts: AudioContext[] }).__contexts.map(
+          (context) => context.state,
+        ),
+      );
+
+    await page.goto("/albums/album-2");
+    await page.getByRole("button", { name: "Play album" }).click();
+    await expect(page.locator(".player-track strong")).toHaveText(
+      "Hidden Place",
+    );
+    await expect
+      .poll(states)
+      .toEqual([kind === "running" ? "running" : "suspended"]);
+
+    // Dispatched rather than clicked, as in the cache test: the sidebar's
+    // footer sits under the fixed player bar at this viewport.
+    await page.getByRole("button", { name: "Sign out" }).dispatchEvent("click");
+    await expect(page).toHaveURL(/\/login$/);
+    await expect.poll(states).toEqual(["closed"]);
+  });
+}
diff --git a/webapp/src/player/player.tsx b/webapp/src/player/player.tsx
index e6acac75..742367eb 100644
--- a/webapp/src/player/player.tsx
+++ b/webapp/src/player/player.tsx
@@ -311,6 +311,39 @@ export function PlayerProvider({ children }: { children: ReactNode }) {
   // Kept so a later gesture resumes this one rather than making another.
   const candidate = useRef<AudioContext | null>(null);
   const [gainNode, setGainNode] = useState<GainNode | null>(null);
+  // Whether the provider is mounted, for a graph whose wiring finishes after
+  // a resume: signing out unmounts the player, possibly while one is pending.
+  const graphMounted = useRef(false);
+
+  // Signing out unmounts the player, and an open AudioContext holds the audio
+  // device until it is closed — browsers cap how many a page may have. Both
+  // the candidate and the graph are closed on the way out. The marker is set
+  // again on every mount, because StrictMode and Fast Refresh replay effects
+  // on an instance that stays mounted.
+  useEffect(() => {
+    graphMounted.current = true;
+    return () => {
+      graphMounted.current = false;
+      const pending = candidate.current;
+      candidate.current = null;
+      if (pending) void pending.close().catch(() => undefined);
+      const active = graph.current;
+      if (!active) return;
+      graph.current = null;
+      setGainNode(null);
+      void active.context.close().catch(() => undefined);
+      // The element stays claimed by the context just closed, and would play
+      // as silence on an instance that remounts with its refs kept. It is
+      // dropped, and the mount effect makes a fresh one.
+      const element = audio.current;
+      if (element) {
+        element.pause();
+        element.removeAttribute("src");
+        element.load();
+        audio.current = null;
+      }
+    };
+  }, []);
 
   /**
    * Asks a stopped graph to run again. A play that starts by itself — the
@@ -374,6 +407,11 @@ export function PlayerProvider({ children }: { children: ReactNode }) {
       return gain;
     }).then((gain) => {
       if (candidate.current === context) candidate.current = null;
+      if (!graphMounted.current) {
+        // Unmounted while it waited: nobody will ever close it otherwise.
+        void context.close().catch(() => undefined);
+        return;
+      }
       // No graph: the element keeps playing as it did, unlevelled.
       if (!gain) return;
       graph.current = { context, gain };