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/rfcs/RFC-022-playback-and-web-client.md b/docs/rfcs/RFC-022-playback-and-web-client.md
new file mode 100644
index 00000000..0f266667
--- /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**: [#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,
+  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.
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..3ad80204 100644
--- a/tests/service.rs
+++ b/tests/service.rs
@@ -210,6 +210,81 @@ 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).
+///
+/// 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"),
+    ] {
+        let response = get(path).await;
+        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");
+        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")));
+            }
+        } else {
+            assert_eq!(status, StatusCode::NOT_FOUND, "{path}");
+            assert!(kind.starts_with("application/json"), "{path}");
+        }
+    }
+
+    // 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]
 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"));
+}
diff --git a/webapp/e2e/studio-nocturne.spec.ts b/webapp/e2e/studio-nocturne.spec.ts
index 3aed9511..1f54530e 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,353 @@ 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);
+});
+
+/**
+ * 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 });
+});
+
+/**
+ * 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/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 00000000..50c208e3
Binary files /dev/null and b/webapp/public/apple-touch-icon.png differ
diff --git a/webapp/public/icons/icon-192.png b/webapp/public/icons/icon-192.png
new file mode 100644
index 00000000..e5dd7e03
Binary files /dev/null and b/webapp/public/icons/icon-192.png differ
diff --git a/webapp/public/icons/icon-512.png b/webapp/public/icons/icon-512.png
new file mode 100644
index 00000000..b3787667
Binary files /dev/null and b/webapp/public/icons/icon-512.png differ
diff --git a/webapp/public/icons/maskable-512.png b/webapp/public/icons/maskable-512.png
new file mode 100644
index 00000000..a4232ba2
Binary files /dev/null and b/webapp/public/icons/maskable-512.png differ
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..86f150ae
--- /dev/null
+++ b/webapp/scripts/render-icons.ts
@@ -0,0 +1,88 @@
+/**
+ * Renders the install icons in `public/` from the one mark (RFC-022 decision 4).
+ *
+ * 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:
+ *
+ * - **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/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/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..742367eb 100644
--- a/webapp/src/player/player.tsx
+++ b/webapp/src/player/player.tsx
@@ -22,7 +22,10 @@ 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";
 
 const VOLUME_KEY = "waveflow.volume";
 
@@ -297,6 +300,130 @@ 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);
+  // 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);
+  // 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
+   * 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. 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) {
+      wakeGraph();
+      return;
+    }
+    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;
+    }
+    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;
+      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 };
+      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 =
@@ -377,6 +504,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;
       }
@@ -414,7 +542,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.
@@ -459,6 +587,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 {
@@ -473,7 +602,7 @@ export function PlayerProvider({ children }: { children: ReactNode }) {
       cancelled = true;
       element.removeEventListener("error", onError);
     };
-  }, [current, resolveStream]);
+  }, [current, resolveStream, wakeGraph]);
 
   useEffect(() => {
     const upcoming = queue[index + 1];
@@ -503,24 +632,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 +672,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 +766,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 +777,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 +788,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);