DeadAir in the page: a switch per show, one beside the speed, and the time saved (#172)

A DeadAir switch in each show's settings, and the same switch beside
the speed for the show that is playing, drawn as a waveform with its gap
closed up, outlined when off and solid when on, with aria-pressed. A
file the server gives a copy for plays from /media/{id}/deadair. An
episode's line says how much shorter it is, and Settings says how much
DeadAir has saved you.

Turning it on or off mid-episode saves the place with a request it waits
for, not a beacon, then asks for the entry again from the new
GET /api/entries/{feed}/{guid}, whose position is in the clock of the
version it now plays, and carries on there. A copy not made yet plays
from the next time. Turning a show on wakes the copy maker, so the copy
is there in seconds rather than at its next pass.

The browser test plays a real MP3 with long silences, quiet.mp3, from a
show it adds and removes itself.

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

src/web.rs

@@ -46,6 +46,7 @@ pub fn router(state: WebState) -> Router {
         .route("/api/feeds/{id}", patch(patch_feed).delete(remove_feed))
         .route("/api/feeds/{id}/entries", get(entries))
         .route("/api/entries", get(all_entries))
+        .route("/api/entries/{feed_id}/{guid}", get(one_entry))
         .route("/api/entries/{feed_id}/{guid}/flags", post(set_flags))
         .route("/api/entries/{feed_id}/{guid}/position", post(set_position))
         .route("/api/feeds/{id}/read-all", post(read_all))
@@ -1458,6 +1459,25 @@ async fn entry_page(
     Ok(Json(EntryPage { total, entries: rows }))
 }
 
+/// One entry, in the clock of the file this person will play (`deadair::for_reader`).
+async fn one_entry(
+    State(state): State<WebState>,
+    Path((feed_id, guid)): Path<(String, String)>,
+    user: crate::db::User,
+) -> Result<Json<crate::db::EntryRow>, ApiError> {
+    subscribed(&state, &user, &feed_id).await?;
+    let Some(row) = state.ctx.db.entry(user.id, &feed_id, &guid).await? else {
+        return Err(ApiError::not_found("no such entry"));
+    };
+    let mut rows = [row];
+    crate::deadair::for_reader(&state.ctx, user.id, &mut rows).await?;
+    let [mut row] = rows;
+    if let Some(d) = &row.description {
+        row.description = Some(clean_description(&mut feed_sanitizer(), d, row.link.as_deref()));
+    }
+    Ok(Json(row))
+}
+
 /// Feed HTML is untrusted: it reaches the page only after ammonia has been through it.
 fn feed_sanitizer() -> ammonia::Builder<'static> {
     let mut b = ammonia::Builder::new();
@@ -1600,6 +1620,7 @@ async fn patch_feed(
     }
     if let Some(wanted) = body.deadair {
         state.ctx.db.set_deadair(user.id, &id, wanted).await?;
+        state.ctx.deadair.notify_one();
     }
     // What one person wants -- which items, whether to fetch them, how many at a time --
     // is theirs. It goes on their subscription and nobody else sees the change.