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/db.rs

@@ -1061,12 +1061,22 @@ impl Args {
 /// The FROM and WHERE that `entries_in` and `count_in` share: whose read state, which feeds
 /// (one, or every feed the person subscribes to), the filter, and a case-insensitive search of
 /// title and description.
-fn entries_from(a: &mut Args, user_id: i64, feed_id: Option<&str>, filter: Filter, search: Option<&str>) -> String {
+fn entries_from(
+    a: &mut Args,
+    user_id: i64,
+    feed_id: Option<&str>,
+    filter: Filter,
+    search: Option<&str>,
+    guid: Option<&str>,
+) -> String {
     let user = a.p(user_id);
-    let scope = match feed_id {
+    let mut scope = match feed_id {
         Some(f) => format!("e.feed_id = {}", a.p(f)),
         None => format!("e.feed_id IN (SELECT feed_id FROM subscriptions WHERE user_id = {user})"),
     };
+    if let Some(g) = guid {
+        scope = format!("{scope} AND e.guid = {}", a.p(g));
+    }
     let search = match search.map(|q| q.trim().to_lowercase()).filter(|q| !q.is_empty()) {
         Some(q) => {
             let like = a.p(format!("%{q}%"));
@@ -1198,9 +1208,31 @@ impl Db {
         offset: i64,
         limit: i64,
         order: &str,
+    ) -> Result<Vec<EntryRow>> {
+        self.entries_where(user_id, feed_id, filter, search, None, offset, limit, order).await
+    }
+
+    /// One entry as `entries_in` gives it: what the player asks for again when the clock it
+    /// plays in changes (DeadAir, #171).
+    pub async fn entry(&self, user_id: i64, feed_id: &str, guid: &str) -> Result<Option<EntryRow>> {
+        let order = order_sql("published", "desc");
+        Ok(self.entries_where(user_id, Some(feed_id), Filter::All, None, Some(guid), 0, 1, &order).await?.pop())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    async fn entries_where(
+        &self,
+        user_id: i64,
+        feed_id: Option<&str>,
+        filter: Filter,
+        search: Option<&str>,
+        guid: Option<&str>,
+        offset: i64,
+        limit: i64,
+        order: &str,
     ) -> Result<Vec<EntryRow>> {
         let mut a = Args::default();
-        let from = entries_from(&mut a, user_id, feed_id, filter, search);
+        let from = entries_from(&mut a, user_id, feed_id, filter, search, guid);
         let sql = format!(
             "SELECT e.guid, e.feed_id, e.title, e.link, e.published, e.description,
                     coalesce(s.read, false) AS read, coalesce(s.flagged, false) AS flagged, e.image,
@@ -1263,7 +1295,7 @@ impl Db {
         search: Option<&str>,
     ) -> Result<i64> {
         let mut a = Args::default();
-        let sql = format!("SELECT count(*) AS n {}", entries_from(&mut a, user_id, feed_id, filter, search));
+        let sql = format!("SELECT count(*) AS n {}", entries_from(&mut a, user_id, feed_id, filter, search, None));
         let r = self.rows(&sql, a.0).await?;
         Ok(r.first().context("count(*) always returns a row")?.try_get("", "n")?)
     }

src/deadair.rs

@@ -252,6 +252,7 @@ pub async fn run(ctx: Arc<Ctx>, mut stop: tokio::sync::watch::Receiver<bool>) {
         }
         tokio::select! {
             _ = stop.changed() => return,
+            _ = ctx.deadair.notified() => {}
             _ = tokio::time::sleep(IDLE) => {}
         }
     }

src/main.rs

@@ -153,6 +153,9 @@ pub struct Ctx {
     // own, and a change in flight here can still store over theirs; take the copy from the
     // database rather than memory if that ever happens.
     pub cfg_write: tokio::sync::Mutex<()>,
+    /// Wakes DeadAir's maker when a show is turned on, so its copies start at once instead of
+    /// at the next pass (#171).
+    pub deadair: tokio::sync::Notify,
 }
 
 /// A copy of the config to change, holding off every other change until `store_cfg` keeps it.
@@ -345,6 +348,7 @@ async fn main() -> Result<()> {
         detach_torrents: is_daemon,
         retry: Default::default(),
         cfg_write: Default::default(),
+        deadair: Default::default(),
     });
 
     let result = match cli.command {
@@ -2458,6 +2462,7 @@ mod tests {
             detach_torrents: false,
             retry: Default::default(),
             cfg_write: Default::default(),
+            deadair: Default::default(),
         }
     }
 

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.