@kromatv/sdk 0.1.40-canary.0

package/rust/kroma-db/src/ingest/sync.rs

@@ -0,0 +1,291 @@
+//! The scan diff-sync: libraries, shows and items, then the orphans left behind.
+
+use std::collections::HashMap;
+
+use anyhow::Result;
+use rusqlite::params;
+
+use kroma_domain::{Kind, Library, LibraryKind, MediaItem, Show};
+
+use crate::vectors::prune_orphan_vectors;
+use crate::{now_or_blank, Pool};
+
+use super::probe_result::recompute_all_representatives;
+use super::scanned_files::sync_files;
+
+/// Diff-syncs the scanned index into the DB in one transaction: preserves
+/// `items.metadata`/`shows.metadata` and a file's probed data when its
+/// `size`+`mtime` are unchanged, unlike a blunt DELETE-all + INSERT.
+pub fn sync_all(
+    pool: &Pool,
+    libraries: &[Library],
+    shows: &[Show],
+    items: &[MediaItem],
+    mtimes: &HashMap<String, Option<i64>>,
+) -> Result<()> {
+    let mut conn = pool.get()?;
+    let tx = conn.transaction()?;
+
+    sync_libraries(&tx, libraries)?;
+    sync_shows(&tx, shows)?;
+    sync_items(&tx, items)?;
+    sync_files(&tx, items, mtimes)?;
+    prune_orphans(&tx)?;
+
+    tx.commit()?;
+
+    recompute_all_representatives(pool)?;
+    let _ = prune_orphan_vectors(pool);
+    Ok(())
+}
+
+// Upserts by id, then deletes only libraries no longer scanned: a wholesale
+// DELETE FROM libraries would cascade to items/files and wipe what this sync preserves.
+fn sync_libraries(tx: &rusqlite::Transaction, libraries: &[Library]) -> Result<()> {
+    let mut lib_stmt = tx.prepare(
+        "INSERT INTO libraries (id,name,kind,path,added_at) VALUES (?1,?2,?3,?4,?5) \
+         ON CONFLICT(id) DO UPDATE SET name=excluded.name, kind=excluded.kind, path=excluded.path",
+    )?;
+    for l in libraries {
+        lib_stmt.execute(params![
+            l.id,
+            l.name,
+            library_kind_str(&l.kind),
+            l.path,
+            now_or_blank()
+        ])?;
+    }
+    let keep: Vec<String> = libraries.iter().map(|l| l.id.clone()).collect();
+    let mut existing: Vec<String> = Vec::new();
+    {
+        let mut q = tx.prepare("SELECT id FROM libraries")?;
+        let rows = q.query_map([], |r| r.get::<_, String>(0))?;
+        for r in rows {
+            existing.push(r?);
+        }
+    }
+    let mut del = tx.prepare("DELETE FROM libraries WHERE id = ?1")?;
+    for id in &existing {
+        if !keep.contains(id) {
+            del.execute(params![id])?;
+        }
+    }
+    Ok(())
+}
+
+fn sync_shows(tx: &rusqlite::Transaction, shows: &[Show]) -> Result<()> {
+    let mut show_stmt = tx.prepare(
+        "INSERT INTO shows (id,library,title,year,added_at) VALUES (?1,?2,?3,?4,?5) \
+         ON CONFLICT(id) DO UPDATE SET library=excluded.library, title=excluded.title, \
+             year=COALESCE(excluded.year, shows.year)",
+    )?;
+    for s in shows {
+        show_stmt.execute(params![s.id, s.library, s.title, s.year, s.added_at])?;
+    }
+    Ok(())
+}
+
+fn sync_items(tx: &rusqlite::Transaction, items: &[MediaItem]) -> Result<()> {
+    let mut item_stmt = tx.prepare(
+        "INSERT INTO items \
+            (id,kind,title,year,container,library,show_id,show_title,\
+             season,episode,episode_end,episode_title,rel_path,abs_path,added_at) \
+         VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14,?15) \
+         ON CONFLICT(id) DO UPDATE SET \
+             kind=excluded.kind, title=excluded.title, year=excluded.year, \
+             library=excluded.library, show_id=excluded.show_id, \
+             show_title=excluded.show_title, season=excluded.season, \
+             episode=excluded.episode, episode_end=excluded.episode_end, \
+             episode_title=excluded.episode_title",
+    )?;
+    for i in items {
+        // Seed representative columns from the first file; probing recomputes them.
+        let seed = i.files.first();
+        let container = seed.map(|f| f.container.clone()).unwrap_or_default();
+        let rel_path = seed.and_then(|f| f.rel_path.clone());
+        let abs_path = seed.and_then(|f| f.abs_path.clone());
+        item_stmt.execute(params![
+            i.id,
+            kind_str(&i.kind),
+            i.title,
+            i.year,
+            container,
+            i.library,
+            i.show_id,
+            i.show_title,
+            i.season,
+            i.episode,
+            i.episode_end,
+            i.episode_title,
+            rel_path,
+            abs_path,
+            i.added_at,
+        ])?;
+    }
+    Ok(())
+}
+
+// Prunes items/shows with no backing files, then the language-cache rows for
+// vanished titles (no FK on those tables, so the item/show cascade misses them).
+fn prune_orphans(tx: &rusqlite::Transaction) -> Result<()> {
+    tx.execute(
+        "DELETE FROM items WHERE id NOT IN (SELECT DISTINCT item_id FROM files)",
+        [],
+    )?;
+    tx.execute("DELETE FROM shows WHERE id NOT IN (SELECT DISTINCT show_id FROM items WHERE show_id IS NOT NULL)", [])?;
+
+    tx.execute(
+        "DELETE FROM metadata_core WHERE \
+            (subject_kind='item' AND subject_id NOT IN (SELECT id FROM items)) OR \
+            (subject_kind='show' AND subject_id NOT IN (SELECT id FROM shows))",
+        [],
+    )?;
+    tx.execute(
+        "DELETE FROM translations WHERE subject_kind IN ('item','episode') \
+            AND subject_id NOT IN (SELECT id FROM items)",
+        [],
+    )?;
+    tx.execute(
+        "DELETE FROM translations WHERE subject_kind='show' \
+            AND subject_id NOT IN (SELECT id FROM shows)",
+        [],
+    )?;
+    tx.execute(
+        "DELETE FROM translations WHERE subject_kind='season_cast' \
+            AND substr(subject_id, 1, instr(subject_id, ':') - 1) NOT IN (SELECT id FROM shows)",
+        [],
+    )?;
+    Ok(())
+}
+
+fn kind_str(k: &Kind) -> &'static str {
+    match k {
+        Kind::Movie => "movie",
+        Kind::Episode => "episode",
+        Kind::Video => "video",
+    }
+}
+
+fn library_kind_str(k: &LibraryKind) -> &'static str {
+    match k {
+        LibraryKind::Movies => "movies",
+        LibraryKind::Shows => "shows",
+        LibraryKind::Mixed => "mixed",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ingest::test_support::*;
+    use crate::{
+        item_has_probed_file, item_probed, set_file_probe, set_item_metadata, unprobed_files,
+    };
+
+    #[test]
+    fn sync_all_creates_updates_and_prunes() {
+        let p = pool();
+        let items = vec![
+            movie(
+                "m1",
+                "Dune",
+                "lib",
+                vec![file("f1", "/media/m1.mkv", false)],
+            ),
+            movie(
+                "m2",
+                "Arrival",
+                "lib",
+                vec![file("f2", "/media/m2.mkv", false)],
+            ),
+        ];
+        sync_all(&p, &[lib("lib")], &[], &items, &mtimes_of(&items, 100)).unwrap();
+        assert_eq!(crate::counts(&p).unwrap(), (1, 2, 0));
+        let got = crate::get_item(&p, "m1").unwrap().unwrap();
+        assert_eq!(got.files.len(), 1);
+        assert_eq!(got.container, "mkv"); // seeded from the file until a probe recomputes
+
+        let mut unprobed = unprobed_files(&p).unwrap();
+        unprobed.sort();
+        assert_eq!(unprobed.len(), 2);
+        assert!(unprobed
+            .iter()
+            .any(|(id, abs, item)| id == "f1" && abs == "/media/m1.mkv" && item == "m1"));
+
+        let items = vec![movie(
+            "m1",
+            "Dune",
+            "lib",
+            vec![file("f1", "/media/m1.mkv", false)],
+        )];
+        sync_all(&p, &[lib("lib")], &[], &items, &mtimes_of(&items, 100)).unwrap();
+        assert_eq!(crate::counts(&p).unwrap(), (1, 1, 0));
+        assert!(crate::get_item(&p, "m2").unwrap().is_none());
+    }
+
+    #[test]
+    fn sync_preserves_metadata_and_probe_across_rescans() {
+        let p = pool();
+        let items = vec![movie(
+            "m1",
+            "Dune",
+            "lib",
+            vec![file("f1", "/media/m1.mkv", false)],
+        )];
+        sync_all(&p, &[lib("lib")], &[], &items, &mtimes_of(&items, 100)).unwrap();
+
+        set_file_probe(&p, "f1", Some(7_200_000), Some(&video()), None, &[], &[]).unwrap();
+        set_item_metadata(&p, "m1", &meta(603, "Dune")).unwrap();
+        assert!(item_has_probed_file(&p, "m1").unwrap());
+
+        sync_all(&p, &[lib("lib")], &[], &items, &mtimes_of(&items, 100)).unwrap();
+        assert!(
+            item_probed(&p, "m1").unwrap(),
+            "unchanged file keeps probed=1"
+        );
+        let got = crate::get_item(&p, "m1").unwrap().unwrap();
+        assert_eq!(got.metadata.as_ref().map(|m| m.tmdb_id), Some(603));
+
+        sync_all(&p, &[lib("lib")], &[], &items, &mtimes_of(&items, 999)).unwrap();
+        assert!(
+            !item_probed(&p, "m1").unwrap(),
+            "changed file resets probed=0"
+        );
+        assert!(crate::get_item(&p, "m1")
+            .unwrap()
+            .unwrap()
+            .metadata
+            .is_some());
+    }
+
+    #[test]
+    fn a_scan_that_cannot_write_an_item_fails_whole_rather_than_half() {
+        let p = pool();
+        p.get()
+            .unwrap()
+            .execute_batch(
+                "CREATE TRIGGER no_item_insert BEFORE INSERT ON items \
+                 BEGIN SELECT RAISE(ABORT, 'refused'); END",
+            )
+            .unwrap();
+
+        let items = vec![movie(
+            "m1",
+            "Dune",
+            "lib",
+            vec![file("f1", "/media/m1.mkv", false)],
+        )];
+        assert!(sync_all(&p, &[lib("lib")], &[], &items, &HashMap::new()).is_err());
+    }
+
+    #[test]
+    fn every_kind_is_stored_under_the_spelling_the_queries_filter_on() {
+        assert_eq!(kind_str(&Kind::Movie), "movie");
+        assert_eq!(kind_str(&Kind::Episode), "episode");
+        assert_eq!(kind_str(&Kind::Video), "video");
+
+        assert_eq!(library_kind_str(&LibraryKind::Movies), "movies");
+        assert_eq!(library_kind_str(&LibraryKind::Shows), "shows");
+        assert_eq!(library_kind_str(&LibraryKind::Mixed), "mixed");
+    }
+}

package/rust/kroma-db/src/ingest/test_support.rs

@@ -0,0 +1,114 @@
+use crate::testing::TempPool;
+use kroma_domain::{
+    CastMember, Kind, Library, LibraryKind, MediaFile, MediaItem, Metadata, VideoStream,
+};
+use std::collections::HashMap;
+
+pub(super) fn pool() -> TempPool {
+    crate::testing::temp_pool("ingest")
+}
+
+pub(super) fn video() -> VideoStream {
+    VideoStream {
+        codec: "hevc".into(),
+        width: Some(3840),
+        height: Some(2160),
+        hdr: false,
+        bit_depth: Some(10),
+    }
+}
+
+pub(super) fn lib(id: &str) -> Library {
+    Library {
+        id: id.into(),
+        name: "L".into(),
+        kind: LibraryKind::Movies,
+        path: "/x".into(),
+        item_count: 0,
+    }
+}
+
+pub(super) fn file(id: &str, abs: &str, probed: bool) -> MediaFile {
+    MediaFile {
+        id: id.into(),
+        rel_path: Some(format!("{id}.mkv")),
+        container: "mkv".into(),
+        duration_ms: if probed { Some(7_200_000) } else { None },
+        video: if probed { Some(video()) } else { None },
+        audio: None,
+        audio_tracks: Vec::new(),
+        subtitles: Vec::new(),
+        size: Some(1000),
+        edition: None,
+        probed,
+        abs_path: Some(abs.into()),
+    }
+}
+
+pub(super) fn movie(id: &str, title: &str, library: &str, files: Vec<MediaFile>) -> MediaItem {
+    MediaItem {
+        id: id.into(),
+        title: title.into(),
+        kind: Kind::Movie,
+        year: Some(2021),
+        duration_ms: None,
+        container: String::new(),
+        video: None,
+        audio: None,
+        audio_tracks: Vec::new(),
+        subtitles: Vec::new(),
+        library: library.into(),
+        show_id: None,
+        show_title: None,
+        season: None,
+        episode: None,
+        episode_end: None,
+        episode_title: None,
+        rel_path: None,
+        added_at: "t".into(),
+        metadata: None,
+        abs_path: None,
+        files,
+        default_file_id: None,
+        markers: Vec::new(),
+        audio_analysis: None,
+    }
+}
+
+pub(super) fn mtimes_of(items: &[MediaItem], mtime: i64) -> HashMap<String, Option<i64>> {
+    items
+        .iter()
+        .flat_map(|i| i.files.iter())
+        .map(|f| (f.id.clone(), Some(mtime)))
+        .collect()
+}
+
+pub(super) fn meta(tmdb: u64, title: &str) -> Metadata {
+    Metadata {
+        provider: "tmdb",
+        tmdb_id: tmdb,
+        imdb_id: Some("tt1".into()),
+        title: Some(title.into()),
+        tagline: None,
+        overview: Some("an overview".into()),
+        release_date: Some("2021-01-01".into()),
+        genres: vec!["Science Fiction".into()],
+        tmdb_genre_ids: vec![878],
+        rating: Some(8.0),
+        certification: Some("PG-13".into()),
+        poster_url: Some("/api/images/p.webp".into()),
+        backdrop_url: None,
+        logo_url: None,
+        theme_url: None,
+        cast: vec![CastMember {
+            name: "Timothee".into(),
+            tmdb_id: None,
+            character: Some("Paul".into()),
+            profile_url: None,
+        }],
+        crew: vec![],
+        keywords: vec![],
+        tvdb_id: None,
+        tmdb_url: "https://tmdb/1".into(),
+    }
+}

package/rust/kroma-db/src/ingest.rs

@@ -0,0 +1,20 @@
+//! Catalog writes: metadata attachment, ffprobe results and the scan diff-sync.
+//!
+//! Three writers, re-exported flat here so the public `db::<item>` paths resolve
+//! unchanged: [`metadata`] attaches what enrichment resolved, [`probe`] records
+//! what ffprobe found, and [`sync`] with [`scanned_files`] diff-sync what a
+//! library scan saw against what the database already holds.
+
+mod metadata;
+mod probe;
+mod probe_result;
+mod scanned_files;
+mod sync;
+
+#[cfg(test)]
+mod test_support;
+
+pub use metadata::*;
+pub use probe::*;
+pub use probe_result::*;
+pub use sync::*;

package/rust/kroma-db/src/jobs.rs

@@ -0,0 +1,269 @@
+//! Persistence for the background job system: schedule overrides, run records
+//! and per-run log lines. All timestamps are epoch milliseconds.
+
+use super::*;
+
+use kroma_domain::{JobLog, JobRun};
+
+const RUN_COLS: &str = "id,job_key,trigger_kind,status,started_at,finished_at,\
+    progress_done,progress_total,error";
+
+fn row_to_run(r: &Row) -> rusqlite::Result<JobRun> {
+    let started_at: i64 = r.get(4)?;
+    let finished_at: Option<i64> = r.get(5)?;
+    Ok(JobRun {
+        id: r.get(0)?,
+        job_key: r.get(1)?,
+        trigger: r.get(2)?,
+        status: r.get(3)?,
+        started_at,
+        finished_at,
+        duration_ms: finished_at.map(|f| f - started_at),
+        progress_done: r.get(6)?,
+        progress_total: r.get(7)?,
+        error: r.get(8)?,
+    })
+}
+
+/// Every persisted schedule override as `(key, schedule, enabled)`.
+pub fn list_job_schedules(pool: &Pool) -> Result<Vec<(String, Option<String>, bool)>> {
+    let conn = pool.get()?;
+    let mut stmt = conn.prepare("SELECT key, schedule, enabled FROM job_schedules")?;
+    let rows = stmt.query_map([], |r| {
+        Ok((
+            r.get::<_, String>(0)?,
+            r.get::<_, Option<String>>(1)?,
+            r.get::<_, i64>(2)? != 0,
+        ))
+    })?;
+    Ok(rows.collect::<rusqlite::Result<Vec<_>>>()?)
+}
+
+pub fn upsert_job_schedule(
+    pool: &Pool,
+    key: &str,
+    schedule: Option<&str>,
+    enabled: bool,
+) -> Result<()> {
+    let conn = pool.get()?;
+    conn.execute(
+        "INSERT INTO job_schedules (key, schedule, enabled, updated_at) \
+         VALUES (?1, ?2, ?3, ?4) \
+         ON CONFLICT(key) DO UPDATE SET \
+            schedule=excluded.schedule, enabled=excluded.enabled, updated_at=excluded.updated_at",
+        params![key, schedule, enabled as i64, kroma_primitives::now_ms()],
+    )?;
+    Ok(())
+}
+
+pub fn insert_job_run(
+    pool: &Pool,
+    id: &str,
+    key: &str,
+    trigger: &str,
+    started_ms: i64,
+) -> Result<()> {
+    let conn = pool.get()?;
+    conn.execute(
+        "INSERT INTO job_runs (id, job_key, trigger_kind, status, started_at) \
+         VALUES (?1, ?2, ?3, 'running', ?4)",
+        params![id, key, trigger, started_ms],
+    )?;
+    Ok(())
+}
+
+pub fn update_job_run_progress(pool: &Pool, id: &str, done: i64, total: i64) -> Result<()> {
+    let conn = pool.get()?;
+    conn.execute(
+        "UPDATE job_runs SET progress_done=?2, progress_total=?3 WHERE id=?1",
+        params![id, done, total],
+    )?;
+    Ok(())
+}
+
+pub fn finish_job_run(
+    pool: &Pool,
+    id: &str,
+    status: &str,
+    finished_ms: i64,
+    error: Option<&str>,
+) -> Result<()> {
+    let conn = pool.get()?;
+    conn.execute(
+        "UPDATE job_runs SET status=?2, finished_at=?3, error=?4 WHERE id=?1",
+        params![id, status, finished_ms, error],
+    )?;
+    Ok(())
+}
+
+/// Newest first.
+pub fn list_job_runs(pool: &Pool, key: &str, limit: usize) -> Result<Vec<JobRun>> {
+    let conn = pool.get()?;
+    let mut stmt = conn.prepare(&format!(
+        "SELECT {RUN_COLS} FROM job_runs WHERE job_key=?1 ORDER BY started_at DESC LIMIT ?2",
+    ))?;
+    let rows = stmt.query_map(params![key, limit as i64], row_to_run)?;
+    Ok(rows.collect::<rusqlite::Result<Vec<_>>>()?)
+}
+
+pub fn last_job_run(pool: &Pool, key: &str) -> Result<Option<JobRun>> {
+    let conn = pool.get()?;
+    let mut stmt = conn.prepare(&format!(
+        "SELECT {RUN_COLS} FROM job_runs WHERE job_key=?1 ORDER BY started_at DESC LIMIT 1",
+    ))?;
+    let mut rows = stmt.query_map(params![key], row_to_run)?;
+    match rows.next() {
+        Some(r) => Ok(Some(r?)),
+        None => Ok(None),
+    }
+}
+
+/// Mark every run still flagged `running` as `failed`; called once at startup, since
+/// in-process run state does not survive a restart and such a row would otherwise
+/// stay `running` forever. Returns how many were fixed.
+pub fn reconcile_running_runs(pool: &Pool) -> Result<usize> {
+    let conn = pool.get()?;
+    let now = kroma_primitives::now_ms();
+    // Collect the stranded ids first, to leave an explanatory line in each run's own
+    // log rather than have it stop mid-stream with no reason.
+    let ids: Vec<String> = {
+        let mut stmt = conn.prepare("SELECT id FROM job_runs WHERE status='running'")?;
+        let rows = stmt.query_map([], |r| r.get::<_, String>(0))?;
+        rows.collect::<rusqlite::Result<Vec<_>>>()?
+    };
+    for id in &ids {
+        let _ = conn.execute(
+            "INSERT INTO job_logs (run_id, ts, level, message) VALUES (?1, ?2, 'error', ?3)",
+            params![
+                id,
+                now,
+                "run interrupted by a server restart before it could finish (not a job error); trigger it again to build the remaining work"
+            ],
+        );
+    }
+    let n = conn.execute(
+        "UPDATE job_runs SET status='failed', finished_at=?1, \
+         error='interrupted by server restart' WHERE status='running'",
+        params![now],
+    )?;
+    Ok(n)
+}
+
+/// Drop all but the newest `keep` runs for a job, plus any now-orphaned logs.
+pub fn prune_job_runs(pool: &Pool, key: &str, keep: usize) -> Result<()> {
+    let conn = pool.get()?;
+    conn.execute(
+        "DELETE FROM job_runs WHERE job_key=?1 AND id NOT IN \
+         (SELECT id FROM job_runs WHERE job_key=?1 ORDER BY started_at DESC LIMIT ?2)",
+        params![key, keep as i64],
+    )?;
+    conn.execute(
+        "DELETE FROM job_logs WHERE run_id NOT IN (SELECT id FROM job_runs)",
+        [],
+    )?;
+    Ok(())
+}
+
+pub fn insert_job_log(
+    pool: &Pool,
+    run_id: &str,
+    ts: i64,
+    level: &str,
+    message: &str,
+) -> Result<()> {
+    let conn = pool.get()?;
+    conn.execute(
+        "INSERT INTO job_logs (run_id, ts, level, message) VALUES (?1, ?2, ?3, ?4)",
+        params![run_id, ts, level, message],
+    )?;
+    Ok(())
+}
+
+/// The last `limit` lines, in chronological order.
+pub fn list_job_logs(pool: &Pool, run_id: &str, limit: usize) -> Result<Vec<JobLog>> {
+    let conn = pool.get()?;
+    let mut stmt = conn.prepare(
+        "SELECT ts, level, message FROM job_logs WHERE run_id=?1 ORDER BY rowid DESC LIMIT ?2",
+    )?;
+    let rows = stmt.query_map(params![run_id, limit as i64], |r| {
+        Ok(JobLog {
+            ts: r.get(0)?,
+            level: r.get(1)?,
+            message: r.get(2)?,
+        })
+    })?;
+    let mut logs = rows.collect::<rusqlite::Result<Vec<_>>>()?;
+    logs.reverse(); // DESC fetch → chronological
+    Ok(logs)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::testing::TempPool;
+
+    fn pool() -> TempPool {
+        crate::testing::temp_pool("jobs")
+    }
+
+    #[test]
+    fn reconcile_flips_only_running_to_failed() {
+        let p = pool();
+        insert_job_run(&p, "r1", "cache.cleanup", "manual", 1).unwrap();
+        insert_job_run(&p, "r2", "cache.cleanup", "manual", 1).unwrap();
+        finish_job_run(&p, "r2", "success", 2, None).unwrap();
+
+        let n = reconcile_running_runs(&p).unwrap();
+        assert_eq!(n, 1);
+
+        let r1 = last_one(&p, "r1");
+        assert_eq!(r1.status, "failed");
+        assert!(r1.finished_at.is_some());
+        assert!(r1.error.unwrap().contains("restart"));
+        assert_eq!(last_one(&p, "r2").status, "success");
+    }
+
+    #[test]
+    fn the_last_run_is_the_newest_and_a_job_that_never_ran_has_none() {
+        let p = pool();
+        insert_job_run(&p, "r1", "library.scan", "manual", 10).unwrap();
+        insert_job_run(&p, "r2", "library.scan", "schedule", 20).unwrap();
+        assert_eq!(last_job_run(&p, "library.scan").unwrap().unwrap().id, "r2");
+        assert!(last_job_run(&p, "library.never-ran").unwrap().is_none());
+    }
+
+    #[test]
+    fn job_logs_keep_the_newest_window_but_read_oldest_first() {
+        let p = pool();
+        insert_job_run(&p, "r1", "library.scan", "manual", 1).unwrap();
+        for (ts, message) in [(1, "started"), (2, "halfway"), (3, "done")] {
+            insert_job_log(&p, "r1", ts, "info", message).unwrap();
+        }
+
+        let messages = |limit| {
+            list_job_logs(&p, "r1", limit)
+                .unwrap()
+                .into_iter()
+                .map(|l| l.message)
+                .collect::<Vec<_>>()
+        };
+        assert_eq!(messages(10), ["started", "halfway", "done"]);
+        assert_eq!(
+            messages(2),
+            ["halfway", "done"],
+            "a limit drops the OLDEST lines"
+        );
+        assert_eq!(list_job_logs(&p, "r1", 1).unwrap()[0].level, "info");
+        assert!(list_job_logs(&p, "another-run", 10).unwrap().is_empty());
+    }
+
+    fn last_one(p: &Pool, id: &str) -> JobRun {
+        let conn = p.get().unwrap();
+        conn.query_row(
+            &format!("SELECT {RUN_COLS} FROM job_runs WHERE id=?1"),
+            params![id],
+            row_to_run,
+        )
+        .unwrap()
+    }
+}