feat(music): W22 shared listening + release 0.6.0

Personal playlist on a dedicated music player (browse/play/prev/next/
seek/volume/reorder/remove, .pls/.m3u import), plus per-person shared
listening: broadcast your track over presence, peers tune in and stream
it point-to-point over the files plane. Playback is timeline-synced
(play/pause/skip/seek mirror with no drift) with gapless prefetch of the
next track and independent per-source volume per listener.

In the 3-column layout the playlist gets its own card stacked under the
chat, with a resizable divider and its own scrollbar; other layouts keep
it in the Controls panel.

Breaking wire change: gossip protocol v5 (presence gains music fields),
so 0.6.0 peers cannot share a swarm with 0.5.x. Version bumped 0.5.1 ->
0.6.0; CHANGELOG updated.

Untrusted-input handling: broadcast track name sanitized and size
cap-checked at gossip ingest, fetched bytes confirmed audio before
decode, only the descriptor rides gossip (bytes go point-to-point, one
fetch in flight).

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

CHANGELOG.md

@@ -0,0 +1,48 @@
+# Changelog
+
+All notable changes to PeerSpeak are documented here.
+
+## [0.6.0] — 2026-06-28
+
+### Added
+- **Shared music listening (W22).** A new **Playlist** panel lets you build a personal queue of local audio files and play them on a dedicated music player — Browse to add tracks, play/pause, previous/next, seek, per-track reorder, remove, and a local volume slider, all persisted across sessions. `.pls` and `.m3u` playlists can be imported (remote and non-audio entries are skipped).
+- **Tune in to a friend's music.** Flip **"Let others tune in"** and peers see your current track under the **Public** tab; one click on **Listen** streams it to them. Playback is **timeline-synced** — play, pause, skip, and seek mirror across everyone with no drift — and the next track is **prefetched for gapless** transitions. Each listener gets an independent **per-source volume**, so music sits under voice at whatever level they like; voice chat stays fully audible throughout.
+- **Standalone Playlist card in the 3-Column layout.** The playlist now lives in its own card stacked under the chat, with a draggable divider to resize it and its own scrollbar when space is tight. The other layouts keep the playlist in the Controls panel.
+
+### Security
+- Shared-music metadata is treated as untrusted: the broadcast track name is sanitized and its size is cap-checked at gossip ingest, fetched bytes are confirmed to be audio before decoding, and only a small descriptor ever rides gossip — track bytes move point-to-point over the existing files plane, one fetch in flight at a time.
+
+### Changed
+- **Wire protocol bump (gossip v5).** Shared listening adds presence fields, so **0.6.0 peers cannot share a swarm with 0.5.x peers** — everyone in a room must update together.
+
+[0.6.0]: https://gitbutter.xyz/mollusk/peerspeak/releases/tag/v0.6.0
+
+## [0.5.1] — 2026-06-27
+
+### Added
+- **Volume control for inline chat audio clips.** A master volume slider plus a **Universal volume** toggle now sit in the Chat panel header, and every audio attachment gets its own 🔊 slider on its play row. With Universal volume on (the default), one level applies to all clips and persists across sessions; turn it off to give each clip its own independent level.
+
+## [0.5.0] — 2026-06-27
+
+### Added
+- **Right-click context menu** (Cut / Copy / Paste / Select All) on every text-entry field. (A9)
+- **Selectable, copyable text** for values that used to be read-only: your full node ID and the room ticket can now be click-selected and copied, and **chat messages are drag-selectable** (highlight + Ctrl+C / Ctrl+A) while clickable links keep working. (W21 Phase 1 + 2)
+- **Clock-skew warning**: when a peer can't be seen because the two systems' clocks differ by more than the replay-protection window, PeerSpeak now shows a "your clocks are out of sync" banner instead of failing silently. (A25)
+- **Per-application audio capture for screen-share**, removing the call-audio loopback echo when sharing a window, plus surfacing of pixelpass startup errors. (A23)
+
+### Changed / Fixed
+- **Critical commands are now delivered reliably under load** — muting, releasing push-to-talk, and leaving a room can no longer be silently dropped while a slider is being dragged (prevents a hot-mic state mismatch). (A15)
+- Screen-share now passes `--strict-audio` and surfaces app-audio drop warnings; the source picker state machine and pactl handling were hardened. (A23)
+- Per-peer volume control path verified and covered by regression tests. (A24)
+
+### Security
+- Hardened against insider resource-exhaustion: bounded + author-keyed chat attachment cache, capped recovery-identity state, and other Tier-C caps (F-01 / F-02 / F-03 / F-12).
+
+### Packaging
+- Added Debian/Ubuntu `.deb` packaging (cargo-deb metadata); the official `.deb` is now built on **Debian 12 (bookworm)** for wide compatibility.
+- Arch `PKGBUILD` clones over anonymous HTTPS.
+
+[0.5.1]: https://gitbutter.xyz/mollusk/peerspeak/releases/tag/v0.5.1
+[0.5.0]: https://gitbutter.xyz/mollusk/peerspeak/releases/tag/v0.5.0
+
+Earlier releases: see git tags `v0.4.0`, `v0.3.0`, `v0.2.0`.

Cargo.lock

@@ -4871,7 +4871,7 @@ checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec"
 
 [[package]]
 name = "peerspeak"
-version = "0.4.0"
+version = "0.6.0"
 dependencies = [
  "anyhow",
  "async-trait",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "peerspeak"
-version = "0.4.0"
+version = "0.6.0"
 edition = "2024"
 description = "Decentralized peer-to-peer voice chat (Rust/iroh/PipeWire/Opus/iced)"
 # Application crate, not a crates.io library — refuse `cargo publish` and let

packaging/PKGBUILD

@@ -1,7 +1,7 @@
 # Maintainer: mollusk <jitty+lc1iz0dc@protonmail.com>
 pkgname=peerspeak-git
 _pkgname=peerspeak
-pkgver=0.4.0.r254.g913b0b6
+pkgver=0.5.0.r0.g0000000
 pkgrel=1
 pkgdesc="Decentralized peer-to-peer voice chat (Rust/iroh/PipeWire/Opus/iced)"
 arch=('x86_64')
@@ -14,7 +14,7 @@ optdepends=('pixelpass: screen sharing inside a room'
 provides=('peerspeak')
 conflicts=('peerspeak')
 options=('!lto' '!debug')
-source=("$_pkgname::git+ssh://git@gitbutter.xyz/mollusk/peerspeak.git")
+source=("$_pkgname::git+https://gitbutter.xyz/mollusk/peerspeak.git")
 sha256sums=('SKIP')
 
 pkgver() {

packaging/windows/peerspeak.iss

@@ -12,7 +12,7 @@
 ; (x86_64-pc-windows-gnu, statically linked -- no extra DLLs needed).
 
 #define MyAppName "PeerSpeak"
-#define MyAppVersion "0.4.0"
+#define MyAppVersion "0.5.0"
 #define MyAppPublisher "mollusk"
 #define MyAppExeName "peerspeak.exe"
 

src/audio/clip_player.rs

@@ -40,6 +40,7 @@ enum ClipCommand {
     Resume,
     Seek(Duration),
     Stop,
+    SetVolume(f32),
 }
 
 /// Cheap, `Send` command handle for the dedicated playback thread.
@@ -51,13 +52,16 @@ pub struct ClipPlayer {
 impl ClipPlayer {
     /// Start the playback worker. The system output device is opened lazily on
     /// first Play, so merely launching PeerSpeak never claims another stream.
-    pub fn new() -> (Self, SharedClipStatus) {
+    ///
+    /// `initial_volume` is the universal gain (`1.0` = unity) applied to every
+    /// clip, restored from config so the level persists across sessions.
+    pub fn new(initial_volume: f32) -> (Self, SharedClipStatus) {
         let (command_tx, command_rx) = mpsc::channel();
         let status = Arc::new(Mutex::new(ClipStatus::default()));
         let worker_status = Arc::clone(&status);
         std::thread::Builder::new()
             .name("peerspeak-clip-player".to_string())
-            .spawn(move || playback_worker(command_rx, worker_status))
+            .spawn(move || playback_worker(command_rx, worker_status, initial_volume))
             .expect("failed to spawn clip playback thread");
         (
             Self {
@@ -94,11 +98,24 @@ impl ClipPlayer {
     pub fn stop(&self) {
         let _ = self.command_tx.send(ClipCommand::Stop);
     }
+
+    /// Set the universal playback gain (`1.0` = unity). Applies to the current
+    /// clip immediately and to every clip played afterwards.
+    pub fn set_volume(&self, volume: f32) {
+        let _ = self.command_tx.send(ClipCommand::SetVolume(volume));
+    }
 }
 
-fn playback_worker(command_rx: mpsc::Receiver<ClipCommand>, status: SharedClipStatus) {
+fn playback_worker(
+    command_rx: mpsc::Receiver<ClipCommand>,
+    status: SharedClipStatus,
+    initial_volume: f32,
+) {
     let mut output: Option<MixerDeviceSink> = None;
     let mut player: Option<Player> = None;
+    // Universal gain remembered across clips so a level set on one upload
+    // carries to the next; reapplied to each freshly connected player.
+    let mut volume = initial_volume.max(0.0);
 
     loop {
         match command_rx.recv_timeout(Duration::from_millis(100)) {
@@ -124,7 +141,9 @@ fn playback_worker(command_rx: mpsc::Receiver<ClipCommand>, status: SharedClipSt
                 if output.is_none() {
                     match DeviceSinkBuilder::open_default_sink() {
                         Ok(sink) => {
-                            player = Some(Player::connect_new(sink.mixer()));
+                            let new_player = Player::connect_new(sink.mixer());
+                            new_player.set_volume(volume);
+                            player = Some(new_player);
                             output = Some(sink);
                         }
                         Err(error) => {
@@ -177,6 +196,12 @@ fn playback_worker(command_rx: mpsc::Receiver<ClipCommand>, status: SharedClipSt
                 }
                 reset(&status);
             }
+            Ok(ClipCommand::SetVolume(level)) => {
+                volume = level.max(0.0);
+                if let Some(player) = player.as_ref() {
+                    player.set_volume(volume);
+                }
+            }
             Err(mpsc::RecvTimeoutError::Disconnected) => break,
             Err(mpsc::RecvTimeoutError::Timeout) => {}
         }

src/bin/test_net.rs

@@ -65,6 +65,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         sharing: None,
         avatar: Default::default(),
         game: None,
+        music: None,
     };
     room_a.join(&ticket_str, state_a, vec![]).await?;
     println!("Node A joined topic.");
@@ -85,6 +86,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         sharing: None,
         avatar: Default::default(),
         game: None,
+        music: None,
     };
     room_b.join(&ticket_str, state_b, vec![]).await?;
     println!("Node B joined topic.");

src/config.rs

@@ -126,6 +126,10 @@ fn default_chat_height() -> f32 {
     180.0
 }
 
+fn default_threecol_playlist_height() -> f32 {
+    220.0
+}
+
 fn default_controls_width() -> f32 {
     280.0
 }
@@ -156,6 +160,24 @@ pub struct AppConfig {
     /// App-internal playback gain applied to the mixed output (1.0 = unity).
     #[serde(default = "default_volume")]
     pub output_volume: f32,
+    /// Universal playback gain for inline chat audio clips (1.0 = unity). One
+    /// level shared by every uploaded clip so the slider sticks across plays.
+    #[serde(default = "default_volume")]
+    pub clip_volume: f32,
+    /// W22 music: the user's personal playlist as local file PATHS (not bytes).
+    /// Loaded into memory at startup; missing files are skipped/marked on play.
+    #[serde(default)]
+    pub music_playlist: Vec<String>,
+    /// W22 music: local playback gain for the dedicated music player (1.0 = unity).
+    #[serde(default = "default_volume")]
+    pub music_volume: f32,
+    /// W22 music: opt-in shared listening broadcast toggle. Local preference.
+    #[serde(default)]
+    pub music_broadcast: bool,
+    /// When true, `clip_volume` governs every clip. When false, each clip keeps
+    /// its own (in-memory) level and the universal slider is inactive.
+    #[serde(default = "default_true")]
+    pub clip_volume_universal: bool,
     #[serde(default)]
     pub network_mode: NetworkMode,
     /// Presence posture for the friends idle listener (W7): invisible / normal /
@@ -174,6 +196,11 @@ pub struct AppConfig {
     pub participants_width: f32,
     #[serde(default = "default_chat_height")]
     pub chat_height: f32,
+    /// Height (px) of the standalone Playlist card stacked under Chat in the
+    /// 3-column layout. Resized via its own horizontal divider; re-clamped to the
+    /// window on load/resize. Only used by `RoomLayout::ThreeColumn`.
+    #[serde(default = "default_threecol_playlist_height")]
+    pub threecol_playlist_height: f32,
     /// Controls panel width for the 3-column layout (px).
     #[serde(default = "default_controls_width")]
     pub controls_width: f32,
@@ -279,6 +306,11 @@ pub struct AppConfig {
     /// string. Local preference only; never sent to peers. Absent entry = unity.
     #[serde(default)]
     pub peer_volume: HashMap<String, f32>,
+    /// Per-source music listen volume/gain (`1.0` = unity), keyed by peer node id
+    /// string. Local preference only; never sent to peers. Absent entry falls
+    /// back to `music_volume`.
+    #[serde(default)]
+    pub music_source_volume: HashMap<String, f32>,
     /// Per-peer listener-side noise-gate threshold (normalized RMS, `0.0` = off),
     /// keyed by peer node id string. Local preference only; never sent to peers.
     /// Absent entry = gate disabled (pass-through).
@@ -312,12 +344,18 @@ impl Default for AppConfig {
             noise_gate_threshold: 0.01,
             input_volume: 1.0,
             output_volume: 1.0,
+            clip_volume: 1.0,
+            music_playlist: Vec::new(),
+            music_volume: 1.0,
+            music_broadcast: false,
+            clip_volume_universal: true,
             network_mode: NetworkMode::default(),
             presence_mode: crate::presence::PresenceMode::default(),
             echo_cancellation_enabled: false,
             notifications_enabled: true,
             participants_width: default_participants_width(),
             chat_height: default_chat_height(),
+            threecol_playlist_height: default_threecol_playlist_height(),
             controls_width: default_controls_width(),
             chat_drawer_width: default_chat_drawer_width(),
             room_layout: RoomLayout::default(),
@@ -350,6 +388,7 @@ impl Default for AppConfig {
             peer_eq: HashMap::new(),
             peer_pan: HashMap::new(),
             peer_volume: HashMap::new(),
+            music_source_volume: HashMap::new(),
             peer_gate: HashMap::new(),
             hotkeys: crate::hotkeys::HotkeyMap::default(),
             window_width: default_window_width(),
@@ -506,6 +545,7 @@ mod tests {
         assert!(deserialized.peer_eq.is_empty());
         assert!(deserialized.peer_pan.is_empty());
         assert!(deserialized.peer_volume.is_empty());
+        assert!(deserialized.music_source_volume.is_empty());
         assert!(deserialized.peer_gate.is_empty());
         assert_eq!(
             crate::hotkeys::format_binding(
@@ -657,23 +697,44 @@ mod tests {
         let def = AppConfig::default();
         assert_eq!(def.input_volume, 1.0);
         assert_eq!(def.output_volume, 1.0);
+        assert_eq!(def.clip_volume, 1.0);
+        assert!(def.music_playlist.is_empty());
+        assert_eq!(def.music_volume, 1.0);
+        assert!(!def.music_broadcast);
+        assert!(def.clip_volume_universal);
 
         // Missing in JSON → unity (serde default).
         let missing = r#"{"input_device":"","output_device":"","noise_gate_threshold":0.01}"#;
         let cfg_missing: AppConfig = serde_json::from_str(missing).unwrap();
         assert_eq!(cfg_missing.input_volume, 1.0);
         assert_eq!(cfg_missing.output_volume, 1.0);
+        assert_eq!(cfg_missing.clip_volume, 1.0);
+        assert!(cfg_missing.music_playlist.is_empty());
+        assert_eq!(cfg_missing.music_volume, 1.0);
+        assert!(!cfg_missing.music_broadcast);
+        // Configs predating the toggle default to universal mode.
+        assert!(cfg_missing.clip_volume_universal);
 
         // Explicit non-unity values are preserved across a round-trip.
         let cfg = AppConfig {
             input_volume: 1.5,
             output_volume: 0.25,
+            clip_volume: 0.7,
+            music_playlist: vec!["/tmp/song.ogg".to_string()],
+            music_volume: 0.6,
+            music_broadcast: true,
+            clip_volume_universal: false,
             ..AppConfig::default()
         };
         let round_tripped: AppConfig =
             serde_json::from_str(&serde_json::to_string(&cfg).unwrap()).unwrap();
         assert_eq!(round_tripped.input_volume, 1.5);
         assert_eq!(round_tripped.output_volume, 0.25);
+        assert_eq!(round_tripped.clip_volume, 0.7);
+        assert_eq!(round_tripped.music_playlist, vec!["/tmp/song.ogg".to_string()]);
+        assert_eq!(round_tripped.music_volume, 0.6);
+        assert!(round_tripped.music_broadcast);
+        assert!(!round_tripped.clip_volume_universal);
     }
 
     #[test]

src/core/messages.rs

@@ -61,6 +61,17 @@ pub enum CoreCommand {
     /// (used for on-demand file/chip downloads; images are auto-fetched on
     /// receipt). Replies with `AttachmentReady`/`AttachmentFailed`.
     FetchAttachment { from: EndpointId, attachment: crate::files::ChatAttachment },
+    /// Register `data` as fetchable under `id` for room members (the current
+    /// broadcast track). Called once per track when broadcasting.
+    ServeMusicTrack { id: crate::files::AttachmentId, data: std::sync::Arc<Vec<u8>> },
+    /// Drop a music blob that is no longer current-or-next.
+    ForgetMusicTrack(crate::files::AttachmentId),
+    /// Set (or clear) our broadcast music timeline and re-announce presence.
+    SetMusicPresence(Option<crate::network::MusicPresence>),
+    /// Fetch a source peer's current track bytes after tuning into them.
+    FetchMusic { from: EndpointId, id: crate::files::AttachmentId, size: u64 },
+    /// Fetch a source peer's advertised next track bytes before it becomes current.
+    PrefetchMusic { from: EndpointId, id: crate::files::AttachmentId, size: u64 },
     /// Set the pixelpass binary location (config override, empty = use `$PATH`).
     /// Sent at startup so screen-share can resolve the binary.
     SetPixelpassPath(Option<String>),
@@ -163,6 +174,22 @@ pub fn delivery_class(cmd: &CoreCommand) -> DeliveryClass {
             from: _,
             attachment: _,
         }
+        | CoreCommand::ServeMusicTrack {
+            id: _,
+            data: _,
+        }
+        | CoreCommand::ForgetMusicTrack(_)
+        | CoreCommand::SetMusicPresence(_)
+        | CoreCommand::FetchMusic {
+            from: _,
+            id: _,
+            size: _,
+        }
+        | CoreCommand::PrefetchMusic {
+            from: _,
+            id: _,
+            size: _,
+        }
         | CoreCommand::SetPixelpassPath(_)
         | CoreCommand::ListAudioApps
         | CoreCommand::StartScreenShare { audio_app: _ }
@@ -221,6 +248,12 @@ pub enum UiEvent {
     AttachmentReady { from: EndpointId, id: crate::files::AttachmentId, data: Vec<u8> },
     /// An attachment fetch failed (sender gone, too large, decode error, etc.).
     AttachmentFailed { from: EndpointId, id: crate::files::AttachmentId, error: String },
+    /// A tuned-in source's track bytes arrived; play them in the music sink.
+    MusicReady { from: EndpointId, id: crate::files::AttachmentId, data: Vec<u8> },
+    /// A tuned-in source's next-track bytes arrived; cache them for a gapless swap.
+    MusicPrefetched { from: EndpointId, id: crate::files::AttachmentId, data: Vec<u8> },
+    /// A music-track fetch failed (source gone, too large, etc.).
+    MusicFetchFailed { from: EndpointId, id: crate::files::AttachmentId, error: String },
     /// The apps currently producing audio, for the screen-share audio picker
     /// (A23). Sorted, deduplicated `application.name`s; empty when nothing is
     /// playing or enumeration isn't available. `app_audio_supported` reports

src/core/mod.rs

@@ -865,6 +865,52 @@ fn spawn_attachment_fetch(
     });
 }
 
+fn spawn_music_fetch(
+    transport: Arc<IrohTransport>,
+    ui_tx: mpsc::Sender<UiEvent>,
+    from: EndpointId,
+    id: crate::files::AttachmentId,
+    size: u64,
+) {
+    tokio::spawn(async move {
+        match transport.fetch_blob(from, id, size).await {
+            Ok(data) => {
+                let _ = ui_tx
+                    .send(UiEvent::MusicReady { from, id, data })
+                    .await;
+            }
+            Err(e) => {
+                let _ = ui_tx
+                    .send(UiEvent::MusicFetchFailed { from, id, error: e.to_string() })
+                    .await;
+            }
+        }
+    });
+}
+
+fn spawn_music_prefetch(
+    transport: Arc<IrohTransport>,
+    ui_tx: mpsc::Sender<UiEvent>,
+    from: EndpointId,
+    id: crate::files::AttachmentId,
+    size: u64,
+) {
+    tokio::spawn(async move {
+        match transport.fetch_blob(from, id, size).await {
+            Ok(data) => {
+                let _ = ui_tx
+                    .send(UiEvent::MusicPrefetched { from, id, data })
+                    .await;
+            }
+            Err(e) => {
+                let _ = ui_tx
+                    .send(UiEvent::MusicFetchFailed { from, id, error: e.to_string() })
+                    .await;
+            }
+        }
+    });
+}
+
 /// Finalize and clear the active recording, if any, emitting `RecordingStopped`.
 /// No-op when not recording. Called on stop, room leave, and room switch so a
 /// recording is always closed cleanly (its WAV size fields patched).
@@ -1036,6 +1082,7 @@ async fn run_core_loop(
         name: "Anonymous".to_string(),
         avatar: crate::avatar::Avatar::default(),
         game: None,
+        music: None,
     };
     // Game detection (W17/W18): a background worker polls Steam state + the process
     // list and publishes the debounced running game on a watch channel. Detection
@@ -2665,6 +2712,54 @@ async fn run_core_loop(
                 }
             }
 
+            CoreCommand::ServeMusicTrack { id, data } => {
+                if let Some(session) = &active_session {
+                    session.transport.serve_attachment(id, data);
+                }
+            }
+
+            CoreCommand::ForgetMusicTrack(id) => {
+                if let Some(session) = &active_session {
+                    session.transport.forget_attachment(id);
+                }
+            }
+
+            CoreCommand::SetMusicPresence(music) => {
+                presence.music = music;
+                if let Some(session) = &active_session {
+                    let self_state = presence.to_state(
+                        is_muted.load(Ordering::Relaxed),
+                        net.endpoint.addr(),
+                        current_sharing.clone(),
+                    );
+                    let _ = session.room_state.update_self_state(self_state).await;
+                }
+            }
+
+            CoreCommand::FetchMusic { from, id, size } => {
+                if let Some(session) = &active_session {
+                    spawn_music_fetch(
+                        session.transport.clone(),
+                        ui_tx.clone(),
+                        from,
+                        id,
+                        size,
+                    );
+                }
+            }
+
+            CoreCommand::PrefetchMusic { from, id, size } => {
+                if let Some(session) = &active_session {
+                    spawn_music_prefetch(
+                        session.transport.clone(),
+                        ui_tx.clone(),
+                        from,
+                        id,
+                        size,
+                    );
+                }
+            }
+
             CoreCommand::SetPixelpassPath(path) => {
                 pixelpass_override = path.filter(|p| !p.trim().is_empty());
             }

src/lib.rs

@@ -20,6 +20,7 @@ pub mod recents;
 pub mod discovery;
 pub mod hotkeys;
 pub mod files;
+pub mod playlist;
 pub mod game;
 pub mod widget;
 

src/network/gossip.rs

@@ -645,6 +645,29 @@ impl RoomState for IrohGossipState {
                                             let cleaned = crate::sanitize::sanitize_game_label(&g);
                                             (!cleaned.is_empty()).then_some(cleaned)
                                         });
+                                        // Music presence is untrusted peer data:
+                                        // the track name is display text (sanitize
+                                        // + cap like the game label) and the size
+                                        // bounds a future fetch (reject anything
+                                        // outside the attachment cap).
+                                        state.music = state.music.and_then(|mut m| {
+                                            let name = crate::sanitize::sanitize_game_label(&m.name);
+                                            if name.is_empty() || !crate::files::size_within_cap(m.size) {
+                                                return None;
+                                            }
+                                            m.name = name;
+                                            if m.next_id.is_some() {
+                                                let ok = m
+                                                    .next_size
+                                                    .map(crate::files::size_within_cap)
+                                                    .unwrap_or(false);
+                                                if !ok {
+                                                    m.next_id = None;
+                                                    m.next_size = None;
+                                                }
+                                            }
+                                            Some(m)
+                                        });
                                         // Bound an insider's advertised address set
                                         // before we retain it / hand it to the dialer
                                         // (Tier C F-01).
@@ -959,6 +982,7 @@ mod tests {
             sharing: None,
             avatar: crate::avatar::Avatar::default(),
             game: None,
+            music: None,
         }
     }
 

src/network/iroh_impl.rs

@@ -594,17 +594,21 @@ impl IrohTransport {
         self.shared.served_files.lock().unwrap().insert(id, bytes);
     }
 
-    /// Fetch a chat attachment's bytes from its sender over the file plane. Dials
-    /// the sender on `FILES_ALPN` (preferring a known full address), writes the
-    /// 32-byte id, and reads the response bounded by the descriptor's declared
-    /// size (which the caller has already validated against the global cap). The
-    /// read limit means a malicious sender can't stream us more than advertised.
-    pub async fn fetch_attachment(
+    /// Drop a previously-served blob (e.g. a music track no longer current-or-next).
+    pub fn forget_attachment(&self, id: AttachmentId) {
+        self.shared.served_files.lock().unwrap().remove(&id);
+    }
+
+    /// Fetch `size` bytes stored under `id` from peer `from` over the files plane.
+    /// Shared core of `fetch_attachment` and music-track fetching: dials
+    /// `FILES_ALPN`, writes the 32-byte id, and reads bounded by `size`.
+    pub async fn fetch_blob(
         &self,
         from: EndpointId,
-        att: &ChatAttachment,
+        id: AttachmentId,
+        size: u64,
     ) -> Result<Vec<u8>, NetError> {
-        if !crate::files::size_within_cap(att.size) {
+        if !crate::files::size_within_cap(size) {
             return Err(NetError::Other("attachment size out of range".to_string()));
         }
         let addr = self.shared.addrs.lock().unwrap().get(&from).cloned();
@@ -623,13 +627,13 @@ impl IrohTransport {
             .open_bi()
             .await
             .map_err(|e| NetError::Other(format!("file fetch: open stream failed: {e}")))?;
-        send.write_all(&att.id)
+        send.write_all(&id)
             .await
             .map_err(|e| NetError::Other(format!("file fetch: request write failed: {e}")))?;
         send.finish()
             .map_err(|e| NetError::Other(format!("file fetch: request finish failed: {e}")))?;
 
-        let read = recv.read_to_end(att.size as usize);
+        let read = recv.read_to_end(size as usize);
         let bytes = tokio::time::timeout(FILE_FETCH_TIMEOUT, read)
             .await
             .map_err(|_| NetError::Other("file fetch: read timed out".to_string()))?
@@ -639,6 +643,15 @@ impl IrohTransport {
         }
         Ok(bytes)
     }
+
+    /// Fetch a chat attachment's bytes from its sender over the file plane.
+    pub async fn fetch_attachment(
+        &self,
+        from: EndpointId,
+        att: &ChatAttachment,
+    ) -> Result<Vec<u8>, NetError> {
+        self.fetch_blob(from, att.id, att.size).await
+    }
 }
 
 #[async_trait]

src/network/mod.rs

@@ -22,6 +22,38 @@ pub enum NetError {
     Other(String),
 }
 
+/// A peer's currently-broadcast music track + playback timeline (W22). Rides
+/// gossip presence so listeners can tune in, follow track changes, and keep in
+/// sync. Untrusted like `name`/`game`: the `name` is sanitized and `size` is
+/// cap-checked at gossip ingest. Bytes never ride gossip — they are fetched
+/// point-to-point over the files plane by `id`, exactly like a chat attachment.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct MusicPresence {
+    /// Files-plane handle to fetch this track's bytes (minted per track by the DJ).
+    pub id: crate::files::AttachmentId,
+    /// Sanitized display name (track filename). Untrusted; cleaned at ingest.
+    pub name: String,
+    /// Byte length, bounds the listener's fetch. Must be `<= MAX_ATTACHMENT_BYTES`.
+    pub size: u64,
+    /// True while the DJ has the track paused.
+    pub paused: bool,
+    /// Wall-clock ms (UNIX epoch) of the timeline anchor. While playing, the true
+    /// playhead is `position_ms + (now_ms - anchor_ms)`; while paused it is
+    /// frozen at `position_ms`. Re-stamped on every play/pause/seek.
+    pub anchor_ms: u64,
+    /// Playhead position (ms) at `anchor_ms`.
+    pub position_ms: u64,
+    /// Files-plane handle for the DJ's NEXT track, so listeners can prefetch it
+    /// for a gapless skip. `None` when there is no distinct next track (single
+    /// item playlist) or the DJ isn't ready. Equals a future `id` once that
+    /// track plays.
+    #[serde(default)]
+    pub next_id: Option<crate::files::AttachmentId>,
+    /// Byte length of the next track; bounds the prefetch. Cap-checked at ingest.
+    #[serde(default)]
+    pub next_size: Option<u64>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct PeerState {
     pub name: String,
@@ -48,6 +80,10 @@ pub struct PeerState {
     /// Defaulted so peers/configs predating the field still deserialize.
     #[serde(default)]
     pub game: Option<String>,
+    /// This peer's currently-broadcast music track and playback timeline, or
+    /// `None` when not broadcasting. Defaulted so pre-W22 peers deserialize.
+    #[serde(default)]
+    pub music: Option<MusicPresence>,
 }
 
 /// The locally-owned, "sticky" pieces of our own presence: the identity fields
@@ -70,6 +106,8 @@ pub struct SelfPresence {
     /// (see `crate::sanitize::sanitize_game_label`) before being stored here, so
     /// the outgoing announce carries a safe value.
     pub game: Option<String>,
+    /// Our current broadcast timeline, or `None` when not broadcasting / not playing.
+    pub music: Option<MusicPresence>,
 }
 
 impl SelfPresence {
@@ -89,6 +127,7 @@ impl SelfPresence {
             sharing,
             avatar: self.avatar.clone(),
             game: self.game.clone(),
+            music: self.music.clone(),
         }
     }
 }
@@ -307,6 +346,7 @@ mod tests {
             sharing: None,
             avatar: crate::avatar::Avatar::default(),
             game: None,
+            music: None,
         }
     }
 
@@ -422,6 +462,7 @@ mod tests {
             name: "Alice".to_string(),
             avatar: crate::avatar::Avatar::default(),
             game: Some("Half-Life 2".to_string()),
+            music: None,
         };
         // Volatile fields come from the call; sticky fields from the struct.
         let muted = presence.to_state(true, addr.clone(), Some("ticket".to_string()));
@@ -445,4 +486,21 @@ mod tests {
         let deserialized: PeerState = serde_json::from_str(&serialized).unwrap();
         assert_eq!(original, deserialized);
     }
+
+    #[test]
+    fn music_presence_serde_round_trip() {
+        let original = MusicPresence {
+            id: [3u8; 32],
+            name: "track.ogg".to_string(),
+            size: 1234,
+            paused: false,
+            anchor_ms: 1_700_000_000_000,
+            position_ms: 42_000,
+            next_id: None,
+            next_size: None,
+        };
+        let serialized = serde_json::to_string(&original).unwrap();
+        let deserialized: MusicPresence = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(original, deserialized);
+    }
 }

src/playlist.rs

@@ -0,0 +1,114 @@
+use std::path::{Path, PathBuf};
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum PlaylistKind {
+    M3u,
+    Pls,
+}
+
+/// Classify a path by extension into a playlist kind, or None if it is not a
+/// recognized playlist file. Case-insensitive: m3u/m3u8 -> M3u, pls -> Pls.
+pub fn playlist_kind(path: &Path) -> Option<PlaylistKind> {
+    let ext = path.extension()?.to_string_lossy();
+    match ext.to_ascii_lowercase().as_str() {
+        "m3u" | "m3u8" => Some(PlaylistKind::M3u),
+        "pls" => Some(PlaylistKind::Pls),
+        _ => None,
+    }
+}
+
+/// Parse an m3u/m3u8 or pls playlist into local audio file paths. Remote entries
+/// (http/https/ftp URLs) and non-audio entries are skipped; relative paths are
+/// resolved against `base_dir` (the playlist file's parent directory). Order is
+/// preserved. Does not touch the filesystem.
+pub fn parse_playlist(contents: &str, base_dir: &Path, kind: PlaylistKind) -> Vec<PathBuf> {
+    let entries: Vec<&str> = match kind {
+        PlaylistKind::M3u => contents
+            .lines()
+            .map(str::trim)
+            .filter(|line| !line.is_empty() && !line.starts_with('#'))
+            .collect(),
+        PlaylistKind::Pls => contents
+            .lines()
+            .filter_map(|line| {
+                let (key, value) = line.split_once('=')?;
+                key.trim()
+                    .to_ascii_lowercase()
+                    .starts_with("file")
+                    .then_some(value.trim())
+            })
+            .filter(|line| !line.is_empty())
+            .collect(),
+    };
+
+    entries
+        .into_iter()
+        .filter_map(|entry| playlist_entry_path(entry, base_dir))
+        .collect()
+}
+
+fn playlist_entry_path(entry: &str, base_dir: &Path) -> Option<PathBuf> {
+    let lower = entry.to_ascii_lowercase();
+    if lower.starts_with("http://")
+        || lower.starts_with("https://")
+        || lower.starts_with("ftp://")
+    {
+        return None;
+    }
+
+    let path = Path::new(entry);
+    let resolved = if path.is_absolute() {
+        path.to_path_buf()
+    } else {
+        base_dir.join(path)
+    };
+    let file_name = resolved.file_name()?.to_string_lossy();
+    crate::files::looks_like_audio_name(&file_name).then_some(resolved)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn m3u_skips_comments_and_remote_urls() {
+        let base = Path::new("/music/lists");
+        let contents = "\
+#EXTM3U
+#EXTINF:123,Artist - Song
+tracks/song.ogg
+https://example.com/stream.mp3
+";
+        assert_eq!(
+            parse_playlist(contents, base, PlaylistKind::M3u),
+            vec![PathBuf::from("/music/lists/tracks/song.ogg")]
+        );
+    }
+
+    #[test]
+    fn pls_keeps_file_values_and_skips_non_audio() {
+        let base = Path::new("/music");
+        let contents = "\
+[playlist]
+File1=one.flac
+Title1=One
+File2=notes.txt
+File3=/var/audio/two.MP3
+";
+        assert_eq!(
+            parse_playlist(contents, base, PlaylistKind::Pls),
+            vec![
+                PathBuf::from("/music/one.flac"),
+                PathBuf::from("/var/audio/two.MP3"),
+            ]
+        );
+    }
+
+    #[test]
+    fn playlist_kind_is_case_insensitive() {
+        assert_eq!(playlist_kind(Path::new("mix.M3U")), Some(PlaylistKind::M3u));
+        assert_eq!(playlist_kind(Path::new("mix.m3u8")), Some(PlaylistKind::M3u));
+        assert_eq!(playlist_kind(Path::new("mix.PLS")), Some(PlaylistKind::Pls));
+        assert_eq!(playlist_kind(Path::new("mix.txt")), None);
+    }
+}

src/protocol.rs

@@ -32,7 +32,14 @@ pub const FRIENDS_PROTO: u32 = 1;
 /// strictly required for decoding — but per the versioning discipline a wire-shape
 /// change is isolated into its own topic + signature domain so v2 and v3 peers
 /// never share a swarm. Resync everyone, exactly like the W4 avatar bump.
-pub const GOSSIP_PROTO: u32 = 3;
+///
+/// v4 (0.6.0): `PeerState` gained an optional `music` presence field carrying a
+/// current shared-listening track descriptor and playback timeline. Bytes still
+/// ride the files plane by id; gossip carries only the descriptor/timeline.
+///
+/// v5 (0.7.0): `MusicPresence` gained optional prefetch hints for the next
+/// track so tuned-in listeners can fetch it before the DJ advances.
+pub const GOSSIP_PROTO: u32 = 5;
 /// File-transfer plane version (chat attachment request/stream shape). Bump on
 /// any change. Mirrored in [`FILES_ALPN`].
 pub const FILES_PROTO: u32 = 1;
@@ -47,7 +54,7 @@ pub const FILES_ALPN: &[u8] = b"peerspeak/files/1";
 /// ed25519 gossip signature domain: `peerspeak-gossip-v<GOSSIP_PROTO>`. Carries
 /// the gossip protocol version into every signed payload — a version mismatch
 /// fails verification (cryptographic separation between gossip versions).
-pub const GOSSIP_SIG_DOMAIN: &str = "peerspeak-gossip-v3";
+pub const GOSSIP_SIG_DOMAIN: &str = "peerspeak-gossip-v5";
 
 /// Version-namespace a room topic so peers on different gossip protocol versions
 /// derive **different subscription topics from the same ticket** and therefore

src/widget/context_input.rs

@@ -105,6 +105,20 @@ where
     ContextInput::new(placeholder, value)
 }
 
+pub fn locked_value<'a, Message, Theme, Renderer>(
+    value: &str,
+    noop: Message,
+) -> ContextInput<'a, Message, Theme, Renderer>
+where
+    Message: Clone + 'a,
+    Theme: text_input::Catalog + 'a,
+    Renderer: text::Renderer,
+{
+    ContextInput::new("", value)
+        .on_input(move |_| noop.clone())
+        .locked(true)
+}
+
 pub struct ContextInput<
     'a,
     Message,
@@ -117,6 +131,7 @@ pub struct ContextInput<
     input: text_input::TextInput<'a, Message, Theme, Renderer>,
     value: String,
     is_secure: bool,
+    locked: bool,
     on_input: Option<Rc<dyn Fn(String) -> Message + 'a>>,
     on_paste: Option<Rc<dyn Fn(String) -> Message + 'a>>,
     style: Option<InputStyleFn<'a, Theme>>,
@@ -134,6 +149,7 @@ where
             input: text_input::TextInput::new(placeholder, value),
             value: value.to_owned(),
             is_secure: false,
+            locked: false,
             on_input: None,
             on_paste: None,
             style: None,
@@ -151,6 +167,11 @@ where
         self
     }
 
+    pub fn locked(mut self, yes: bool) -> Self {
+        self.locked = yes;
+        self
+    }
+
     pub fn on_input(
         mut self,
         on_input: impl Fn(String) -> Message + 'a,
@@ -448,6 +469,7 @@ where
             input_state,
             value: &self.value,
             is_secure: self.is_secure,
+            locked: self.locked,
             on_input: self.on_input.clone(),
             on_paste: self.on_paste.clone(),
             style: self.style.clone(),
@@ -479,6 +501,7 @@ where
     input_state: &'a mut text_input::State<Renderer::Paragraph>,
     value: &'a str,
     is_secure: bool,
+    locked: bool,
     on_input: Option<Rc<dyn Fn(String) -> Message + 'a>>,
     on_paste: Option<Rc<dyn Fn(String) -> Message + 'a>>,
     style: Option<InputStyleFn<'a, Theme>>,
@@ -686,13 +709,13 @@ where
         let has_selection = menu.selection.0 != menu.selection.1;
         let has_value = !text_input::Value::new(self.value).is_empty();
 
-        match action {
-            MenuAction::Cut | MenuAction::Copy => {
-                has_selection && !self.is_secure
-            }
-            MenuAction::Paste => true,
-            MenuAction::SelectAll => has_value,
-        }
+        menu_action_enabled(
+            action,
+            has_selection,
+            has_value,
+            self.is_secure,
+            self.locked,
+        )
     }
 
     fn hit_action(
@@ -811,6 +834,21 @@ fn disabled_color(color: Color) -> Color {
     }
 }
 
+fn menu_action_enabled(
+    action: MenuAction,
+    has_selection: bool,
+    has_value: bool,
+    is_secure: bool,
+    locked: bool,
+) -> bool {
+    match action {
+        MenuAction::Cut => has_selection && !is_secure && !locked,
+        MenuAction::Copy => has_selection && !is_secure,
+        MenuAction::Paste => !locked,
+        MenuAction::SelectAll => has_value,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -891,4 +929,15 @@ mod tests {
             }
         );
     }
+
+    #[test]
+    fn locked_menu_allows_copy_and_select_all_only() {
+        assert!(!menu_action_enabled(MenuAction::Cut, true, true, false, true));
+        assert!(menu_action_enabled(MenuAction::Copy, true, true, false, true));
+        assert!(!menu_action_enabled(MenuAction::Paste, true, true, false, true));
+        assert!(menu_action_enabled(MenuAction::SelectAll, true, true, false, true));
+
+        assert!(!menu_action_enabled(MenuAction::Copy, false, true, false, true));
+        assert!(!menu_action_enabled(MenuAction::SelectAll, false, false, false, true));
+    }
 }

src/widget/mod.rs

@@ -1 +1,2 @@
 pub mod context_input;
+pub mod selectable_text;

src/widget/selectable_text.rs

@@ -0,0 +1,890 @@
+use iced::advanced::clipboard::{self, Clipboard};
+use iced::advanced::layout;
+use iced::advanced::mouse;
+use iced::advanced::renderer;
+use iced::advanced::text::{self as advanced_text, Paragraph, Span};
+use iced::advanced::widget::tree::{self, Tree};
+use iced::advanced::widget::Widget;
+use iced::advanced::{Layout, Shell};
+use iced::widget::text::{
+    self as widget_text, Alignment, Catalog, LineHeight, Shaping, Style, StyleFn,
+    Wrapping,
+};
+use iced::{
+    alignment, Background, Border, Color, Element, Event, Length, Pixels, Point,
+    Rectangle, Size, Vector, keyboard,
+};
+
+const DRAG_THRESHOLD: f32 = 3.0;
+const HIT_SEARCH_STEPS: usize = 24;
+
+// Offsets here are paragraph-global BYTE offsets. `Paragraph::hit_test` returns
+// `Hit::CharOffset(cursor.index)`, and cosmic-text's `cursor.index` is a byte
+// offset WITHIN its buffer line — it discards the line number. That equals the
+// global byte offset only when the text is a single logical line. Chat bodies
+// satisfy this because `app::sanitize_chat` turns every control char (incl. `\n`
+// and `\r`) into a space and collapses whitespace, so a stored message can never
+// contain a newline. If that sanitizer ever starts preserving newlines, this
+// widget's per-line offsets would stop being global and selection/copy across
+// lines would break — revisit then.
+
+pub fn selected_substring(
+    text: &str,
+    anchor: usize,
+    cursor: usize,
+) -> Option<String> {
+    let (start, end) = normalized_byte_range(text, anchor, cursor);
+
+    (start != end).then(|| text[start..end].to_owned())
+}
+
+pub fn select_all(text: &str) -> (usize, usize) {
+    (0, text.len())
+}
+
+fn normalized_byte_range(
+    text: &str,
+    anchor: usize,
+    cursor: usize,
+) -> (usize, usize) {
+    let start = clamp_to_char_boundary(text, anchor.min(cursor));
+    let end = clamp_to_char_boundary(text, anchor.max(cursor));
+
+    (start.min(end), start.max(end))
+}
+
+fn clamp_to_char_boundary(text: &str, offset: usize) -> usize {
+    let mut offset = offset.min(text.len());
+
+    while offset > 0 && !text.is_char_boundary(offset) {
+        offset -= 1;
+    }
+
+    offset
+}
+
+pub fn selectable_rich_text<'a, Link, Message, Theme, Renderer>(
+    spans: impl AsRef<[Span<'a, Link, Renderer::Font>]> + 'a,
+) -> SelectableRichText<'a, Link, Message, Theme, Renderer>
+where
+    Link: Clone + 'static,
+    Theme: Catalog + 'a,
+    Renderer: advanced_text::Renderer,
+    Renderer::Font: 'a,
+{
+    SelectableRichText::with_spans(spans)
+}
+
+pub struct SelectableRichText<
+    'a,
+    Link,
+    Message,
+    Theme = iced::Theme,
+    Renderer = iced::Renderer,
+> where
+    Link: Clone + 'static,
+    Theme: Catalog,
+    Renderer: advanced_text::Renderer,
+{
+    spans: Box<dyn AsRef<[Span<'a, Link, Renderer::Font>]> + 'a>,
+    size: Option<Pixels>,
+    line_height: LineHeight,
+    width: Length,
+    height: Length,
+    font: Option<Renderer::Font>,
+    align_x: Alignment,
+    align_y: alignment::Vertical,
+    wrapping: Wrapping,
+    class: Theme::Class<'a>,
+    hovered_link: Option<usize>,
+    on_link_click: Option<Box<dyn Fn(Link) -> Message + 'a>>,
+    selection_color: Color,
+}
+
+impl<'a, Link, Message, Theme, Renderer>
+    SelectableRichText<'a, Link, Message, Theme, Renderer>
+where
+    Link: Clone + 'static,
+    Theme: Catalog,
+    Renderer: advanced_text::Renderer,
+    Renderer::Font: 'a,
+{
+    pub fn new() -> Self {
+        Self {
+            spans: Box::new([]),
+            size: None,
+            line_height: LineHeight::default(),
+            width: Length::Shrink,
+            height: Length::Shrink,
+            font: None,
+            align_x: Alignment::Default,
+            align_y: alignment::Vertical::Top,
+            wrapping: Wrapping::default(),
+            class: Theme::default(),
+            hovered_link: None,
+            on_link_click: None,
+            selection_color: Color::from_rgba(0.35, 0.55, 0.95, 0.35),
+        }
+    }
+
+    pub fn with_spans(
+        spans: impl AsRef<[Span<'a, Link, Renderer::Font>]> + 'a,
+    ) -> Self {
+        Self {
+            spans: Box::new(spans),
+            ..Self::new()
+        }
+    }
+
+    pub fn size(mut self, size: impl Into<Pixels>) -> Self {
+        self.size = Some(size.into());
+        self
+    }
+
+    pub fn line_height(mut self, line_height: impl Into<LineHeight>) -> Self {
+        self.line_height = line_height.into();
+        self
+    }
+
+    pub fn font(mut self, font: impl Into<Renderer::Font>) -> Self {
+        self.font = Some(font.into());
+        self
+    }
+
+    pub fn width(mut self, width: impl Into<Length>) -> Self {
+        self.width = width.into();
+        self
+    }
+
+    pub fn height(mut self, height: impl Into<Length>) -> Self {
+        self.height = height.into();
+        self
+    }
+
+    pub fn align_x(mut self, alignment: impl Into<Alignment>) -> Self {
+        self.align_x = alignment.into();
+        self
+    }
+
+    pub fn align_y(
+        mut self,
+        alignment: impl Into<alignment::Vertical>,
+    ) -> Self {
+        self.align_y = alignment.into();
+        self
+    }
+
+    pub fn wrapping(mut self, wrapping: Wrapping) -> Self {
+        self.wrapping = wrapping;
+        self
+    }
+
+    pub fn on_link_click(
+        mut self,
+        on_link_click: impl Fn(Link) -> Message + 'a,
+    ) -> Self {
+        self.on_link_click = Some(Box::new(on_link_click));
+        self
+    }
+
+    pub fn selection_color(mut self, color: Color) -> Self {
+        self.selection_color = Color {
+            a: color.a.min(0.35),
+            ..color
+        };
+        self
+    }
+
+    pub fn style(mut self, style: impl Fn(&Theme) -> Style + 'a) -> Self
+    where
+        Theme::Class<'a>: From<StyleFn<'a, Theme>>,
+    {
+        self.class = (Box::new(style) as StyleFn<'a, Theme>).into();
+        self
+    }
+
+    pub fn color(self, color: impl Into<Color>) -> Self
+    where
+        Theme::Class<'a>: From<StyleFn<'a, Theme>>,
+    {
+        self.color_maybe(Some(color))
+    }
+
+    pub fn color_maybe(self, color: Option<impl Into<Color>>) -> Self
+    where
+        Theme::Class<'a>: From<StyleFn<'a, Theme>>,
+    {
+        let color = color.map(Into::into);
+
+        self.style(move |_theme| Style { color })
+    }
+
+    pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
+        self.class = class.into();
+        self
+    }
+}
+
+impl<'a, Link, Message, Theme, Renderer> Default
+    for SelectableRichText<'a, Link, Message, Theme, Renderer>
+where
+    Link: Clone + 'static,
+    Theme: Catalog,
+    Renderer: advanced_text::Renderer,
+    Renderer::Font: 'a,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+struct SelectableTextState<Link, P: Paragraph> {
+    spans: Vec<Span<'static, Link, P::Font>>,
+    span_pressed: Option<usize>,
+    paragraph: P,
+    selection: Option<(usize, usize)>,
+    dragging: bool,
+    active: bool,
+    press_position: Option<Point>,
+}
+
+impl<Link, P: Paragraph> SelectableTextState<Link, P> {
+    fn selection_range(&self, text: &str) -> Option<(usize, usize)> {
+        let (anchor, cursor) = self.selection?;
+        let (start, end) = normalized_byte_range(text, anchor, cursor);
+
+        (start != end).then_some((start, end))
+    }
+}
+
+impl<Link, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
+    for SelectableRichText<'_, Link, Message, Theme, Renderer>
+where
+    Link: Clone + 'static,
+    Theme: Catalog,
+    Renderer: advanced_text::Renderer,
+{
+    fn tag(&self) -> tree::Tag {
+        tree::Tag::of::<SelectableTextState<Link, Renderer::Paragraph>>()
+    }
+
+    fn state(&self) -> tree::State {
+        tree::State::new(SelectableTextState::<Link, _> {
+            spans: Vec::new(),
+            span_pressed: None,
+            paragraph: Renderer::Paragraph::default(),
+            selection: None,
+            dragging: false,
+            active: false,
+            press_position: None,
+        })
+    }
+
+    fn size(&self) -> Size<Length> {
+        Size {
+            width: self.width,
+            height: self.height,
+        }
+    }
+
+    fn layout(
+        &mut self,
+        tree: &mut Tree,
+        renderer: &Renderer,
+        limits: &layout::Limits,
+    ) -> layout::Node {
+        layout_text(
+            tree.state
+                .downcast_mut::<SelectableTextState<Link, Renderer::Paragraph>>(),
+            renderer,
+            limits,
+            TextLayout {
+                width: self.width,
+                height: self.height,
+                spans: self.spans.as_ref().as_ref(),
+                line_height: self.line_height,
+                size: self.size,
+                font: self.font,
+                align_x: self.align_x,
+                align_y: self.align_y,
+                wrapping: self.wrapping,
+            },
+        )
+    }
+
+    fn draw(
+        &self,
+        tree: &Tree,
+        renderer: &mut Renderer,
+        theme: &Theme,
+        defaults: &renderer::Style,
+        layout: Layout<'_>,
+        _cursor: mouse::Cursor,
+        viewport: &Rectangle,
+    ) {
+        if !layout.bounds().intersects(viewport) {
+            return;
+        }
+
+        let state = tree
+            .state
+            .downcast_ref::<SelectableTextState<Link, Renderer::Paragraph>>();
+        let spans = self.spans.as_ref().as_ref();
+        let flat_text = flatten_spans(spans);
+        let style = theme.style(&self.class);
+        let translation = layout.position() - Point::ORIGIN;
+
+        if let Some((start, end)) = state.selection_range(&flat_text) {
+            let mut rects = selection_rects(&state.paragraph, spans.len(), start, end);
+            if rects.is_empty() {
+                rects = visual_lines(&state.paragraph, spans.len());
+            }
+
+            for bounds in rects {
+                renderer.fill_quad(
+                    renderer::Quad {
+                        bounds: bounds + translation,
+                        border: Border {
+                            radius: 2.0.into(),
+                            ..Border::default()
+                        },
+                        ..renderer::Quad::default()
+                    },
+                    Background::Color(self.selection_color),
+                );
+            }
+        }
+
+        for (index, span) in spans.iter().enumerate() {
+            let is_hovered_link = self.on_link_click.is_some()
+                && Some(index) == self.hovered_link;
+
+            if span.highlight.is_some()
+                || span.underline
+                || span.strikethrough
+                || is_hovered_link
+            {
+                let regions = state.paragraph.span_bounds(index);
+
+                if let Some(highlight) = span.highlight {
+                    for bounds in &regions {
+                        let bounds = Rectangle::new(
+                            bounds.position()
+                                - Vector::new(
+                                    span.padding.left,
+                                    span.padding.top,
+                                ),
+                            bounds.size()
+                                + Size::new(span.padding.x(), span.padding.y()),
+                        );
+
+                        renderer.fill_quad(
+                            renderer::Quad {
+                                bounds: bounds + translation,
+                                border: highlight.border,
+                                ..Default::default()
+                            },
+                            highlight.background,
+                        );
+                    }
+                }
+
+                if span.underline || span.strikethrough || is_hovered_link {
+                    let size = span
+                        .size
+                        .or(self.size)
+                        .unwrap_or(renderer.default_size());
+
+                    let line_height = span
+                        .line_height
+                        .unwrap_or(self.line_height)
+                        .to_absolute(size);
+
+                    let color = span
+                        .color
+                        .or(style.color)
+                        .unwrap_or(defaults.text_color);
+
+                    let baseline = translation
+                        + Vector::new(
+                            0.0,
+                            size.0 + (line_height.0 - size.0) / 2.0,
+                        );
+
+                    if span.underline || is_hovered_link {
+                        for bounds in &regions {
+                            renderer.fill_quad(
+                                renderer::Quad {
+                                    bounds: Rectangle::new(
+                                        bounds.position() + baseline
+                                            - Vector::new(0.0, size.0 * 0.08),
+                                        Size::new(bounds.width, 1.0),
+                                    ),
+                                    ..Default::default()
+                                },
+                                color,
+                            );
+                        }
+                    }
+
+                    if span.strikethrough {
+                        for bounds in &regions {
+                            renderer.fill_quad(
+                                renderer::Quad {
+                                    bounds: Rectangle::new(
+                                        bounds.position() + baseline
+                                            - Vector::new(0.0, size.0 / 2.0),
+                                        Size::new(bounds.width, 1.0),
+                                    ),
+                                    ..Default::default()
+                                },
+                                color,
+                            );
+                        }
+                    }
+                }
+            }
+        }
+
+        widget_text::draw(
+            renderer,
+            defaults,
+            layout.bounds(),
+            &state.paragraph,
+            style,
+            viewport,
+        );
+    }
+
+    fn update(
+        &mut self,
+        tree: &mut Tree,
+        event: &Event,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        _renderer: &Renderer,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+        _viewport: &Rectangle,
+    ) {
+        let bounds = layout.bounds();
+        let local_position = cursor.position_in(bounds);
+        let state = tree
+            .state
+            .downcast_mut::<SelectableTextState<Link, Renderer::Paragraph>>();
+        let spans = self.spans.as_ref().as_ref();
+        let flat_text = flatten_spans(spans);
+
+        let was_hovered = self.hovered_link.is_some();
+        self.hovered_link = local_position.and_then(|position| {
+            state.paragraph.hit_span(position).and_then(|span| {
+                if spans.get(span)?.link.is_some() {
+                    Some(span)
+                } else {
+                    None
+                }
+            })
+        });
+
+        if was_hovered != self.hovered_link.is_some() {
+            shell.request_redraw();
+        }
+
+        match event {
+            Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => {
+                if let Some(position) = local_position {
+                    state.active = true;
+                    state.dragging = true;
+                    state.press_position = Some(position);
+                    state.span_pressed = self.hovered_link;
+                    state.selection = state
+                        .paragraph
+                        .hit_test(position)
+                        .map(|hit| {
+                            let offset = hit.cursor().min(flat_text.len());
+                            (offset, offset)
+                        });
+                    shell.capture_event();
+                    shell.request_redraw();
+                } else if state.active || state.selection.is_some() {
+                    state.active = false;
+                    state.dragging = false;
+                    state.press_position = None;
+                    state.span_pressed = None;
+                    state.selection = None;
+                    shell.request_redraw();
+                }
+            }
+            Event::Mouse(mouse::Event::CursorMoved { .. }) => {
+                if state.dragging
+                    && let Some(position) = clamped_position(cursor, bounds)
+                    && let Some(hit) = state.paragraph.hit_test(position)
+                    && let Some((anchor, _)) = state.selection
+                {
+                    state.selection =
+                        Some((anchor, hit.cursor().min(flat_text.len())));
+                    shell.request_redraw();
+                }
+            }
+            Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)) => {
+                if state.dragging {
+                    let release_position = clamped_position(cursor, bounds)
+                        .or(local_position)
+                        .or(state.press_position);
+                    let dragged = state
+                        .press_position
+                        .zip(release_position)
+                        .is_some_and(|(start, end)| point_distance(start, end) > DRAG_THRESHOLD);
+
+                    if let Some(position) = release_position
+                        && let Some(hit) = state.paragraph.hit_test(position)
+                        && let Some((anchor, _)) = state.selection
+                    {
+                        state.selection =
+                            Some((anchor, hit.cursor().min(flat_text.len())));
+                    }
+
+                    if !dragged {
+                        if let (Some(on_link_clicked), Some(span)) =
+                            (&self.on_link_click, state.span_pressed)
+                            && Some(span) == self.hovered_link
+                            && let Some(link) =
+                                spans.get(span).and_then(|span| span.link.clone())
+                        {
+                            shell.publish(on_link_clicked(link));
+                        }
+                        state.selection = None;
+                    } else if state.selection_range(&flat_text).is_none() {
+                        state.selection = None;
+                    }
+
+                    state.dragging = false;
+                    state.span_pressed = None;
+                    state.press_position = None;
+                    shell.capture_event();
+                    shell.request_redraw();
+                }
+            }
+            Event::Keyboard(keyboard::Event::KeyPressed {
+                key,
+                physical_key,
+                modifiers,
+                ..
+            }) if state.active && modifiers.command() => {
+                match key.to_latin(*physical_key) {
+                    Some('c') | Some('C') => {
+                        if let Some((anchor, cursor)) = state.selection
+                            && let Some(selected) =
+                                selected_substring(&flat_text, anchor, cursor)
+                        {
+                            clipboard.write(clipboard::Kind::Standard, selected);
+                            shell.capture_event();
+                        }
+                    }
+                    Some('a') | Some('A') => {
+                        state.selection = Some(select_all(&flat_text));
+                        shell.capture_event();
+                        shell.request_redraw();
+                    }
+                    _ => {}
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn mouse_interaction(
+        &self,
+        tree: &Tree,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        _viewport: &Rectangle,
+        _renderer: &Renderer,
+    ) -> mouse::Interaction {
+        let state = tree
+            .state
+            .downcast_ref::<SelectableTextState<Link, Renderer::Paragraph>>();
+
+        if state.dragging {
+            mouse::Interaction::Text
+        } else if self.hovered_link.is_some() {
+            mouse::Interaction::Pointer
+        } else if cursor.is_over(layout.bounds()) {
+            mouse::Interaction::Text
+        } else {
+            mouse::Interaction::None
+        }
+    }
+}
+
+struct TextLayout<'a, 'span, Link, Font> {
+    width: Length,
+    height: Length,
+    spans: &'a [Span<'span, Link, Font>],
+    line_height: LineHeight,
+    size: Option<Pixels>,
+    font: Option<Font>,
+    align_x: Alignment,
+    align_y: alignment::Vertical,
+    wrapping: Wrapping,
+}
+
+fn layout_text<Link, Renderer>(
+    state: &mut SelectableTextState<Link, Renderer::Paragraph>,
+    renderer: &Renderer,
+    limits: &layout::Limits,
+    config: TextLayout<'_, '_, Link, Renderer::Font>,
+) -> layout::Node
+where
+    Link: Clone,
+    Renderer: advanced_text::Renderer,
+{
+    layout::sized(limits, config.width, config.height, |limits| {
+        let bounds = limits.max();
+        let size = config.size.unwrap_or_else(|| renderer.default_size());
+        let font = config.font.unwrap_or_else(|| renderer.default_font());
+
+        let text_with_spans = || advanced_text::Text {
+            content: config.spans,
+            bounds,
+            size,
+            line_height: config.line_height,
+            font,
+            align_x: config.align_x,
+            align_y: config.align_y,
+            shaping: Shaping::Advanced,
+            wrapping: config.wrapping,
+        };
+
+        if state.spans != config.spans {
+            state.paragraph =
+                Renderer::Paragraph::with_spans(text_with_spans());
+            state.spans = config
+                .spans
+                .iter()
+                .cloned()
+                .map(Span::to_static)
+                .collect();
+        } else {
+            match state.paragraph.compare(advanced_text::Text {
+                content: (),
+                bounds,
+                size,
+                line_height: config.line_height,
+                font,
+                align_x: config.align_x,
+                align_y: config.align_y,
+                shaping: Shaping::Advanced,
+                wrapping: config.wrapping,
+            }) {
+                advanced_text::Difference::None => {}
+                advanced_text::Difference::Bounds => {
+                    state.paragraph.resize(bounds);
+                }
+                advanced_text::Difference::Shape => {
+                    state.paragraph =
+                        Renderer::Paragraph::with_spans(text_with_spans());
+                }
+            }
+        }
+
+        state.paragraph.min_bounds()
+    })
+}
+
+fn flatten_spans<Link, Font>(spans: &[Span<'_, Link, Font>]) -> String {
+    spans
+        .iter()
+        .map(|span| span.text.as_ref())
+        .collect::<String>()
+}
+
+fn selection_rects<P: Paragraph>(
+    paragraph: &P,
+    span_count: usize,
+    start: usize,
+    end: usize,
+) -> Vec<Rectangle> {
+    visual_lines(paragraph, span_count)
+        .into_iter()
+        .filter_map(|line| selection_rect_for_line(paragraph, line, start, end))
+        .collect()
+}
+
+fn selection_rect_for_line<P: Paragraph>(
+    paragraph: &P,
+    line: Rectangle,
+    start: usize,
+    end: usize,
+) -> Option<Rectangle> {
+    let y = line.center_y();
+    let paragraph_width = paragraph.bounds().width.max(line.x + line.width + 1.0);
+    let left_probe = line.x.max(0.0);
+    let right_probe = (line.x + line.width + 1.0).min(paragraph_width.max(1.0));
+    let line_start = paragraph
+        .hit_test(Point::new(left_probe, y))
+        .map(advanced_text::Hit::cursor)?;
+    let line_end = paragraph
+        .hit_test(Point::new(right_probe, y))
+        .map(advanced_text::Hit::cursor)
+        .unwrap_or(line_start);
+    let (line_start, line_end) = if line_start <= line_end {
+        (line_start, line_end)
+    } else {
+        (line_end, line_start)
+    };
+    let overlap_start = start.max(line_start);
+    let overlap_end = end.min(line_end);
+
+    if overlap_start >= overlap_end {
+        return None;
+    }
+
+    let x_start = if overlap_start <= line_start {
+        line.x
+    } else {
+        x_for_offset(paragraph, y, overlap_start, line.x, line.x + line.width)
+    };
+    let x_end = if overlap_end >= line_end {
+        line.x + line.width
+    } else {
+        x_for_offset(paragraph, y, overlap_end, line.x, line.x + line.width)
+    };
+    let left = x_start.min(x_end);
+    let right = x_start.max(x_end);
+
+    (right > left).then(|| {
+        Rectangle::new(
+            Point::new(left, line.y),
+            Size::new(right - left, line.height),
+        )
+    })
+}
+
+fn x_for_offset<P: Paragraph>(
+    paragraph: &P,
+    y: f32,
+    offset: usize,
+    left: f32,
+    right: f32,
+) -> f32 {
+    let mut low = left;
+    let mut high = right.max(left);
+
+    for _ in 0..HIT_SEARCH_STEPS {
+        let mid = (low + high) / 2.0;
+        let hit = paragraph
+            .hit_test(Point::new(mid, y))
+            .map(advanced_text::Hit::cursor);
+
+        match hit {
+            Some(hit) if hit < offset => low = mid,
+            Some(_) => high = mid,
+            None => break,
+        }
+    }
+
+    high
+}
+
+fn visual_lines<P: Paragraph>(
+    paragraph: &P,
+    span_count: usize,
+) -> Vec<Rectangle> {
+    let mut lines: Vec<Rectangle> = Vec::new();
+
+    for span in 0..span_count {
+        for bounds in paragraph.span_bounds(span) {
+            if bounds.width <= 0.0 || bounds.height <= 0.0 {
+                continue;
+            }
+
+            if let Some(line) = lines
+                .iter_mut()
+                .find(|line| (line.center_y() - bounds.center_y()).abs() < 1.0)
+            {
+                *line = union(*line, bounds);
+            } else {
+                lines.push(bounds);
+            }
+        }
+    }
+
+    lines.sort_by(|a, b| a.y.total_cmp(&b.y));
+    lines
+}
+
+fn union(a: Rectangle, b: Rectangle) -> Rectangle {
+    let left = a.x.min(b.x);
+    let top = a.y.min(b.y);
+    let right = (a.x + a.width).max(b.x + b.width);
+    let bottom = (a.y + a.height).max(b.y + b.height);
+
+    Rectangle::new(
+        Point::new(left, top),
+        Size::new(right - left, bottom - top),
+    )
+}
+
+fn clamped_position(cursor: mouse::Cursor, bounds: Rectangle) -> Option<Point> {
+    cursor.position_from(bounds.position()).map(|position| {
+        Point::new(
+            position.x.clamp(0.0, bounds.width.max(1.0) - 1.0),
+            position.y.clamp(0.0, bounds.height.max(1.0) - 1.0),
+        )
+    })
+}
+
+fn point_distance(a: Point, b: Point) -> f32 {
+    let dx = a.x - b.x;
+    let dy = a.y - b.y;
+
+    (dx * dx + dy * dy).sqrt()
+}
+
+impl<'a, Link, Message, Theme, Renderer>
+    From<SelectableRichText<'a, Link, Message, Theme, Renderer>>
+    for Element<'a, Message, Theme, Renderer>
+where
+    Message: 'a,
+    Link: Clone + 'a,
+    Theme: Catalog + 'a,
+    Renderer: advanced_text::Renderer + 'a,
+{
+    fn from(
+        text: SelectableRichText<'a, Link, Message, Theme, Renderer>,
+    ) -> Element<'a, Message, Theme, Renderer> {
+        Element::new(text)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn selected_substring_returns_middle_and_none_for_collapsed() {
+        assert_eq!(selected_substring("abcdef", 2, 5), Some("cde".to_owned()));
+        assert_eq!(selected_substring("abcdef", 3, 3), None);
+    }
+
+    #[test]
+    fn selected_substring_handles_reversed_range() {
+        assert_eq!(selected_substring("abcdef", 5, 2), Some("cde".to_owned()));
+    }
+
+    #[test]
+    fn select_all_uses_byte_length() {
+        assert_eq!(select_all(""), (0, 0));
+        assert_eq!(select_all("aé👍z"), (0, "aé👍z".len()));
+    }
+
+    #[test]
+    fn unicode_selection_uses_byte_offsets_without_panicking() {
+        let text = "aé👍z";
+
+        assert_eq!(selected_substring(text, 1, 7), Some("é👍".to_owned()));
+        assert_eq!(selected_substring(text, 3, 7), Some("👍".to_owned()));
+        assert_eq!(selected_substring(text, 2, 7), Some("é👍".to_owned()));
+    }
+}

tests/gossip_rebootstrap.rs

@@ -64,6 +64,7 @@ fn state(name: &str, addr: EndpointAddr) -> PeerState {
         sharing: None,
         avatar: Default::default(),
         game: None,
+        music: None,
     }
 }