@kromatv/sdk 0.1.40-canary.0

package/rust/kroma-domain/src/requests/ledger.rs

@@ -0,0 +1,129 @@
+//! A request's wanted ledger and the calendar/missing feeds built from it.
+
+use serde::Serialize;
+
+use super::{RequestCoverage, RequestKind};
+
+/// One row of a request's wanted ledger: exactly what the search can be aimed
+/// at, and what state that piece is in. `GET /api/requests/:id/wanted`, sorted
+/// by season then episode; a movie request answers with one seasonless row.
+/// `air_date` is `YYYY-MM-DD` or `None` for an undated row (legacy ledgers,
+/// specials); `status` is `wanted` | `grabbed` | `available`.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WantedEntry {
+    pub id: String,
+    pub season: Option<u32>,
+    pub episode: Option<u32>,
+    pub air_date: Option<String>,
+    pub status: String,
+}
+
+/// One season of the requested title as TMDB knows it, tallied against the
+/// request's ledger and the library. `GET /api/requests/:id/ledger`, ascending;
+/// a movie request answers with an empty list. The counts are over the whole
+/// season, not the requested subset: `requested` is how much of it the request
+/// covers, `on_disk` how much the library already holds.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LedgerSeason {
+    pub season: u32,
+    pub name: Option<String>,
+    pub air_date: Option<String>,
+    pub episode_count: u32,
+    pub requested: u32,
+    pub on_disk: u32,
+}
+
+/// One episode of a season, as TMDB describes it, joined with what the request
+/// and the library know about it. `wanted_id` is `None` for an episode the
+/// request does not cover: it can still be searched, it is simply not tracked.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LedgerEpisode {
+    pub season: u32,
+    pub episode: u32,
+    pub name: Option<String>,
+    pub overview: Option<String>,
+    pub air_date: Option<String>,
+    pub still_url: Option<String>,
+    pub rating: Option<f32>,
+    pub on_disk: bool,
+    pub wanted_id: Option<String>,
+    /// The wanted row's status (`wanted` | `grabbed` | `available`), or `None`
+    /// when the request does not cover this episode.
+    pub wanted_status: Option<String>,
+    /// The catalog item this episode already is, when the library holds it: what
+    /// a "watch it" link points at, and what says how good the copy is.
+    pub item_id: Option<String>,
+    pub video: Option<crate::media::VideoStream>,
+    pub duration_ms: Option<i64>,
+}
+
+/// `GET /api/requests/:id/ledger` the requested title as TMDB describes it,
+/// which is wider than the request: an admin sees the seasons and episodes the
+/// request left out, and what the library holds of them.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RequestLedgerView {
+    pub kind: RequestKind,
+    pub tmdb_id: u64,
+    pub title: String,
+    pub year: Option<u32>,
+    /// `YYYY-MM-DD` in UTC, so the client dates "unaired" against the same clock
+    /// the search gate uses.
+    pub today: String,
+    /// What the request covers right now, in the shape the coverage editor
+    /// speaks. Named apart from `seasons` below, which is the TITLE's seasons.
+    pub coverage: RequestCoverage,
+    pub poster_url: Option<String>,
+    pub backdrop_url: Option<String>,
+    pub overview: Option<String>,
+    pub seasons: Vec<LedgerSeason>,
+    /// The catalog entry this title already is (a show id, or a movie's item
+    /// id), when the library holds it at all.
+    pub local_id: Option<String>,
+    /// Movie only: whether the library already holds the film, and the soonest
+    /// date it can be looked for. Always `false` / `None` for a show, whose
+    /// answer is per episode.
+    pub on_disk: bool,
+    pub air_date: Option<String>,
+}
+
+/// `GET /api/requests/:id/ledger/:season` one season's episodes, fetched from
+/// TMDB on demand so a twenty-season show is not twenty round trips a page load.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SeasonLedgerView {
+    pub season: u32,
+    pub episodes: Vec<LedgerEpisode>,
+}
+
+/// One wanted item joined with its request's display fields, shared by two
+/// feeds: the "coming soon" calendar (`GET /api/requests/calendar`, future-dated,
+/// `air_date` always `Some`) and the "missing / wanted" list
+/// (`GET /api/requests/missing`, already aired/released but not on disk, where
+/// `air_date` may be `None` for an undated row). Emitted sorted (calendar: by
+/// date; missing: by title then season/episode).
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CalendarEntry {
+    // The parent request, or `None` for a library-scan "missing" row (a series
+    // in the library with aired episodes not on disk, that was never requested).
+    // The client turns such a row into a request when the user asks to watch it.
+    pub request_id: Option<String>,
+    pub tmdb_id: u64,
+    pub kind: RequestKind,
+    pub title: String,
+    pub year: Option<u32>,
+    pub poster_url: Option<String>,
+    // Present for a show episode; `None` for a movie.
+    pub season: Option<u32>,
+    pub episode: Option<u32>,
+    // `YYYY-MM-DD`. Always set on the calendar feed; may be `None` on the missing
+    // feed (an undated aired row).
+    pub air_date: Option<String>,
+    // The wanted row's status (`wanted` / `grabbed`): a grabbed-but-unaired
+    // episode is already secured, shown differently on the calendar.
+    pub status: String,
+}

package/rust/kroma-domain/src/requests/mod.rs

@@ -0,0 +1,238 @@
+//! Media requests (the "ask for a title" flow) + TMDB discovery wire types.
+//! Pure data (serde + ts-rs); persistence lives in `crate::db`, orchestration
+//! in `crate::services::requests`, the TMDB adapter in `crate::infra::metadata`.
+//!
+//! The JSON shape here is a public contract web/TV clients depend on it, so
+//! field names and casing must not drift. Timestamps are epoch milliseconds.
+
+use serde::{Deserialize, Serialize};
+
+mod discover;
+mod ledger;
+
+pub use discover::*;
+pub use ledger::*;
+
+/// What a request targets. Requests key on TMDB ids, so this mirrors TMDB's
+/// movie/tv split under the catalog's own vocabulary (a "show", not a "tv").
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum RequestKind {
+    Movie,
+    Show,
+}
+
+impl RequestKind {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            RequestKind::Movie => "movie",
+            RequestKind::Show => "show",
+        }
+    }
+    pub fn parse(s: &str) -> Option<RequestKind> {
+        match s {
+            "movie" => Some(RequestKind::Movie),
+            "show" => Some(RequestKind::Show),
+            _ => None,
+        }
+    }
+}
+
+/// A request's lifecycle state. The DB stores the durable states; the transient
+/// acquisition states (`searching`/`downloading`/`importing`) are derived from
+/// the wanted/downloads ledgers when a view is built, so clients get one enum
+/// for the whole status chip vocabulary.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum RequestStatus {
+    Pending,
+    Approved,
+    Searching,
+    Downloading,
+    Importing,
+    Available,
+    PartiallyAvailable,
+    Failed,
+    Denied,
+}
+
+impl RequestStatus {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            RequestStatus::Pending => "pending",
+            RequestStatus::Approved => "approved",
+            RequestStatus::Searching => "searching",
+            RequestStatus::Downloading => "downloading",
+            RequestStatus::Importing => "importing",
+            RequestStatus::Available => "available",
+            RequestStatus::PartiallyAvailable => "partially_available",
+            RequestStatus::Failed => "failed",
+            RequestStatus::Denied => "denied",
+        }
+    }
+    pub fn parse(s: &str) -> Option<RequestStatus> {
+        match s {
+            "pending" => Some(RequestStatus::Pending),
+            "approved" => Some(RequestStatus::Approved),
+            "searching" => Some(RequestStatus::Searching),
+            "downloading" => Some(RequestStatus::Downloading),
+            "importing" => Some(RequestStatus::Importing),
+            "available" => Some(RequestStatus::Available),
+            "partially_available" => Some(RequestStatus::PartiallyAvailable),
+            "failed" => Some(RequestStatus::Failed),
+            "denied" => Some(RequestStatus::Denied),
+            _ => None,
+        }
+    }
+}
+
+/// One (season, episode) pair, for a request that targets individual episodes
+/// rather than whole seasons. `1`-based, mirroring TMDB's numbering.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EpisodeRef {
+    pub season: u32,
+    pub episode: u32,
+}
+
+/// One media request, as listed to clients (the requester sees their own; a
+/// `requests.manage` holder sees everyone's, with the requester hydrated).
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MediaRequest {
+    pub id: String,
+    pub kind: RequestKind,
+    pub tmdb_id: u64,
+    // Denormalized at request time so list views need no TMDB call.
+    pub title: String,
+    pub year: Option<u32>,
+    pub poster_url: Option<String>,
+    // Requested season numbers; `None` = the whole show (or a movie).
+    pub seasons: Option<Vec<u32>>,
+    // Individual episodes requested alongside any full seasons. `None` = none.
+    // A show's target is the union of `seasons` (full) and `episodes`; both
+    // `None` = every season.
+    pub episodes: Option<Vec<EpisodeRef>>,
+    pub status: RequestStatus,
+    pub requested_by: Option<String>,
+    pub requested_by_name: Option<String>,
+    pub reviewed_by: Option<String>,
+    pub note: Option<String>,
+    pub created_at: i64,
+    pub updated_at: i64,
+    // Live download progress (0..1) when the request is `downloading` /
+    // `importing`, derived from its download rows. `None` otherwise.
+    #[serde(default)]
+    pub progress: Option<f64>,
+    // TMDB airing status, refreshed by the `acquisition.refresh` job (show:
+    // "Returning Series"/"Ended"/…; movie: "Released"/"Post Production"/…).
+    // `None` until the first refresh.
+    pub air_status: Option<String>,
+    // Next air date (`YYYY-MM-DD`): a show's next episode, or an unreleased
+    // movie's soonest availability. `None` once nothing more is upcoming.
+    pub next_air_date: Option<String>,
+    // Epoch-ms of the last TMDB refresh (throttles the refresh pass). Internal:
+    // never serialized to clients.
+    #[serde(skip)]
+    pub last_refresh_at: Option<i64>,
+}
+
+/// Status tallies for the admin queue's filter chips.
+#[derive(Debug, Clone, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RequestCounts {
+    pub total: u32,
+    pub pending: u32,
+    pub active: u32,
+    pub available: u32,
+    pub denied: u32,
+    pub failed: u32,
+}
+
+/// `GET /api/requests`.
+#[derive(Debug, Clone, Serialize)]
+pub struct RequestsView {
+    pub requests: Vec<MediaRequest>,
+    pub counts: RequestCounts,
+}
+
+/// What a show request covers: the union of whole `seasons` and individual
+/// `episodes`; both `None` means the whole show. The same shape
+/// `PUT /api/requests/:id/coverage` accepts, so the editor reads and writes one
+/// vocabulary.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RequestCoverage {
+    pub seasons: Option<Vec<u32>>,
+    pub episodes: Option<Vec<EpisodeRef>>,
+}
+
+/// `POST /api/requests` body.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateRequestBody {
+    pub kind: RequestKind,
+    pub tmdb_id: u64,
+    // For shows: the seasons to request; `None`/empty = every season.
+    #[serde(default)]
+    pub seasons: Option<Vec<u32>>,
+    // For shows: individual episodes to request, unioned with `seasons`.
+    // `None`/empty = no per-episode ask.
+    #[serde(default)]
+    pub episodes: Option<Vec<EpisodeRef>>,
+}
+
+/// `PUT /api/requests/:id/coverage` body: exactly what a show request covers
+/// from now on. Both absent (or empty) means the WHOLE show; otherwise the union
+/// of the named seasons and the named episodes. Unlike a second ask, this can
+/// narrow as well as widen.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RequestCoverageBody {
+    #[serde(default)]
+    pub seasons: Option<Vec<u32>>,
+    #[serde(default)]
+    pub episodes: Option<Vec<EpisodeRef>>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn every_request_kind_round_trips_through_its_stored_spelling() {
+        for kind in [RequestKind::Movie, RequestKind::Show] {
+            let stored = kind.as_str();
+            assert_eq!(
+                serde_json::to_string(&kind).unwrap(),
+                format!("\"{stored}\"")
+            );
+            assert_eq!(RequestKind::parse(stored), Some(kind));
+        }
+        assert_eq!(RequestKind::parse("season"), None);
+    }
+
+    #[test]
+    fn every_status_including_the_transient_ones_round_trips() {
+        for status in [
+            RequestStatus::Pending,
+            RequestStatus::Approved,
+            RequestStatus::Searching,
+            RequestStatus::Downloading,
+            RequestStatus::Importing,
+            RequestStatus::Available,
+            RequestStatus::PartiallyAvailable,
+            RequestStatus::Failed,
+            RequestStatus::Denied,
+        ] {
+            let stored = status.as_str();
+            assert_eq!(
+                serde_json::to_string(&status).unwrap(),
+                format!("\"{stored}\"")
+            );
+            assert_eq!(RequestStatus::parse(stored), Some(status));
+        }
+        assert_eq!(RequestStatus::parse("partiallyAvailable"), None);
+        assert_eq!(RequestStatus::parse("cancelled"), None);
+    }
+}

package/rust/kroma-domain/src/section.rs

@@ -0,0 +1,44 @@
+//! A home-screen section: a titled, ranked rail of entries produced by the
+//! section generator (`crate::services::sections`). The client renders these
+//! generically it doesn't know what each section *means*, just how to draw a
+//! titled row of cards. Adding/retuning sections is therefore a server-only change.
+
+use serde::Serialize;
+
+use crate::media::{MediaItem, Show};
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Section {
+    // Stable-ish key for list rendering / focus restoration (e.g.
+    // `"themed:heist"`, `"for-you"`).
+    pub id: String,
+    // Localized, ready-to-display heading (the server resolves i18n, so clients
+    // stay generic).
+    pub title: String,
+    // Optional secondary line, e.g. "Parce que vous avez regardé Mad Max".
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reason: Option<String>,
+    // The rail's entries — movies *or* shows — already capped and de-duplicated
+    // against earlier rows. A `type`-tagged union so the client switches on it
+    // (mirrors `SearchHit`): a movie carries a `MediaItem`, a show a `Show`.
+    pub items: Vec<SectionItem>,
+}
+
+/// One rail entry: a movie/video (a [`MediaItem`]) or a whole show (a [`Show`]).
+/// Both are embedded + ranked by the recommender, so a row can mix them.
+#[derive(Debug, Clone, Serialize)]
+#[serde(tag = "type", rename_all = "lowercase")]
+pub enum SectionItem {
+    Movie { item: Box<MediaItem> },
+    Show { show: Box<Show> },
+}
+
+impl SectionItem {
+    /// The entry's stable id (item or show id) used for cross-row de-dup.
+    pub fn id(&self) -> &str {
+        match self {
+            SectionItem::Movie { item } => &item.id,
+            SectionItem::Show { show } => &show.id,
+        }
+    }
+}

package/rust/kroma-domain/src/slug.rs

@@ -0,0 +1,165 @@
+// Every Latin letter whose NFD form is an ASCII letter plus combining marks,
+// which is the set the TypeScript side folds by decomposing. Generated over
+// Latin-1, Extended-A/B and Extended Additional, so the Vietnamese vowels and
+// the dotted-below transliteration letters fold here too rather than becoming
+// separators on this side only. A letter with no
+// such decomposition (`ß`, `æ`, `ø`, `ð`, `ł`) is NOT here: both sides turn it
+// into a separator, and `slug.fixture.json` holds them to that.
+const LATIN_FOLD: [(&str, char); 25] = [
+    ("àáâãäåāăąǎǟǡǻȁȃȧḁạảấầẩẫậắằẳẵặ", 'a'),
+    ("ḃḅḇ", 'b'),
+    ("çćĉċčḉ", 'c'),
+    ("ďḋḍḏḑḓ", 'd'),
+    ("èéêëēĕėęěȅȇȩḕḗḙḛḝẹẻẽếềểễệ", 'e'),
+    ("ḟ", 'f'),
+    ("ĝğġģǧǵḡ", 'g'),
+    ("ĥȟḣḥḧḩḫẖ", 'h'),
+    ("ìíîïĩīĭįǐȉȋḭḯỉị", 'i'),
+    ("ĵǰ", 'j'),
+    ("ķǩḱḳḵ", 'k'),
+    ("ĺļľḷḹḻḽ", 'l'),
+    ("ḿṁṃ", 'm'),
+    ("ñńņňǹṅṇṉṋ", 'n'),
+    ("òóôõöōŏőơǒǫǭȍȏȫȭȯȱṍṏṑṓọỏốồổỗộớờởỡợ", 'o'),
+    ("ṕṗ", 'p'),
+    ("ŕŗřȑȓṙṛṝṟ", 'r'),
+    ("śŝşšșṡṣṥṧṩ", 's'),
+    ("ţťțṫṭṯṱẗ", 't'),
+    ("ùúûüũūŭůűųưǔǖǘǚǜȕȗṳṵṷṹṻụủứừửữự", 'u'),
+    ("ṽṿ", 'v'),
+    ("ŵẁẃẅẇẉẘ", 'w'),
+    ("ẋẍ", 'x'),
+    ("ýÿŷȳẏẙỳỵỷỹ", 'y'),
+    ("źżžẑẓẕ", 'z'),
+];
+
+/// The URL segment a display name folds to: lowercased, accents dropped, every
+/// run of anything else turned into one `-`, with no leading or trailing one.
+/// Idempotent.
+pub fn slugify(raw: &str) -> String {
+    let mut out = String::with_capacity(raw.len());
+    for ch in raw.chars().flat_map(char::to_lowercase) {
+        if is_combining_mark(ch) {
+            continue;
+        }
+        match base_letter(ch) {
+            Some(base) => out.push(base),
+            None if !out.is_empty() && !out.ends_with('-') => out.push('-'),
+            None => {}
+        }
+    }
+    out.trim_end_matches('-').to_string()
+}
+
+/// Whether `raw` slugifies to `slug`, without building the slug. The credit
+/// scan asks this of every name in the library, so the allocation slugify makes
+/// per call is the cost being avoided rather than a micro-optimisation.
+pub fn slug_eq(raw: &str, slug: &str) -> bool {
+    let mut want = slug.chars();
+    let mut pending_separator = false;
+    let mut any = false;
+    for ch in raw.chars().flat_map(char::to_lowercase) {
+        if is_combining_mark(ch) {
+            continue;
+        }
+        match base_letter(ch) {
+            Some(base) => {
+                if pending_separator {
+                    if want.next() != Some('-') {
+                        return false;
+                    }
+                    pending_separator = false;
+                }
+                if want.next() != Some(base) {
+                    return false;
+                }
+                any = true;
+            }
+            // A run of anything else is one separator, and a trailing run is
+            // none at all: the same shape `slugify` produces.
+            None if any => pending_separator = true,
+            None => {}
+        }
+    }
+    want.next().is_none()
+}
+
+fn is_combining_mark(ch: char) -> bool {
+    matches!(ch, '\u{0300}'..='\u{036F}')
+}
+
+fn base_letter(ch: char) -> Option<char> {
+    if ch.is_ascii_alphanumeric() {
+        return Some(ch);
+    }
+    LATIN_FOLD
+        .iter()
+        .find(|(accented, _)| accented.contains(ch))
+        .map(|&(_, base)| base)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use serde::Deserialize;
+
+    #[derive(Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    struct Case {
+        name: String,
+        slug: String,
+    }
+
+    const SHARED_CASES: &str = include_str!("../../../../packages/core/src/slug.fixture.json");
+
+    fn shared_cases() -> Vec<Case> {
+        serde_json::from_str(SHARED_CASES).expect("slug.fixture.json is not the expected shape")
+    }
+
+    #[test]
+    fn every_shared_case_folds_the_way_the_typescript_slugifier_folds_it() {
+        for Case { name, slug } in shared_cases() {
+            assert_eq!(slugify(&name), slug, "folding {name:?}");
+        }
+    }
+
+    #[test]
+    fn slug_eq_answers_for_every_shared_case_what_slugify_would_have_built() {
+        for Case { name, slug } in shared_cases() {
+            assert!(slug_eq(&name, &slug), "{name:?} should equal {slug:?}");
+            assert!(!slug_eq(&name, &format!("{slug}x")), "{name:?} vs a longer slug");
+            if !slug.is_empty() {
+                assert!(
+                    !slug_eq(&name, &slug[..slug.len() - 1]),
+                    "{name:?} vs a shorter slug"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn slug_eq_reads_a_separator_run_and_a_trailing_run_as_slugify_does() {
+        assert!(slug_eq("Ana  de  Armas", "ana-de-armas"));
+        assert!(slug_eq("Sammy Davis Jr.", "sammy-davis-jr"));
+        assert!(slug_eq("  Michelle Yeoh  ", "michelle-yeoh"));
+        assert!(!slug_eq("Ana de Armas", "ana--de-armas"));
+        assert!(!slug_eq("Sammy Davis Jr.", "sammy-davis-jr-"));
+    }
+
+    #[test]
+    fn a_slug_read_back_off_a_url_folds_to_itself() {
+        for Case { slug, .. } in shared_cases() {
+            assert_eq!(slugify(&slug), slug);
+        }
+    }
+
+    #[test]
+    fn two_spellings_of_one_name_fold_together_and_two_names_stay_apart() {
+        assert_eq!(
+            slugify("  DENIS   villeneuve "),
+            slugify("Denis Villeneuve")
+        );
+        assert_ne!(slugify("Conan O'Brien"), slugify("Conan OBrien"));
+    }
+}

package/rust/kroma-http/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "kroma-http"
+version = "0.1.40-canary.0"
+edition = "2021"
+rust-version = "1.88"
+description = "KROMA's two HTTP transports: a curl process per call for the outside world, and a pooled client for the loopback seam between the core and its module sidecars"
+license = "MIT"
+
+[dependencies]
+anyhow = { version = "1" }
+# curl's header dump goes to a guarded temp file, so a failed spawn leaves none.
+tempfile = { version = "3" }
+serde = { version = "1", features = ["derive"] }
+serde_json = { version = "1" }
+hyper = { version = "1", features = ["client", "http1"] }
+hyper-util = { version = "0.1", features = ["client-legacy", "http1", "tokio"] }
+http-body-util = { version = "0.1" }
+bytes = { version = "1" }
+tokio = { version = "1", features = ["full"] }
+form_urlencoded = "1"

package/rust/kroma-http/examples/seam-bench.rs

@@ -0,0 +1,73 @@
+//! What one exchange on the internal seam costs, per transport.
+//!
+//!     cargo run -p kroma-http --release --example seam-bench
+
+use std::io::{Read, Write};
+use std::net::TcpListener;
+use std::time::{Duration, Instant};
+
+use kroma_http::{Fetch, Loopback};
+
+const BODY: &str = r#"{"ok":true,"items":[]}"#;
+const CALLS: u32 = 200;
+
+fn serve() -> u16 {
+    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+    let port = listener.local_addr().unwrap().port();
+    let response = format!(
+        "HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: keep-alive\r\n\r\n{BODY}",
+        BODY.len()
+    );
+    std::thread::spawn(move || {
+        for mut stream in listener.incoming().flatten() {
+            stream.set_nodelay(true).ok();
+            let response = response.clone();
+            std::thread::spawn(move || {
+                let mut buf = [0u8; 16384];
+                while matches!(stream.read(&mut buf), Ok(n) if n > 0) {
+                    if stream.write_all(response.as_bytes()).is_err() {
+                        return;
+                    }
+                }
+            });
+        }
+    });
+    port
+}
+
+fn time(label: &str, mut call: impl FnMut()) -> Duration {
+    call();
+    let start = Instant::now();
+    for _ in 0..CALLS {
+        call();
+    }
+    let elapsed = start.elapsed();
+    let per_call = elapsed.as_secs_f64() * 1000.0 / f64::from(CALLS);
+    println!("  {label:<38} {per_call:>9.3} ms/call");
+    elapsed
+}
+
+fn main() {
+    let port = serve();
+    let url = format!("http://127.0.0.1:{port}/_port/acquisition/search");
+    let body = serde_json::json!({ "query": "test", "limit": 50 });
+
+    println!("\n  {CALLS} POSTs to a loopback peer, one warm-up call each\n");
+
+    let curl = time("Fetch (a curl process per call)", || {
+        Fetch::new()
+            .header("authorization", "Bearer tok")
+            .post_json(&url, &body)
+            .unwrap();
+    });
+
+    let tcp = time("Loopback / tcp", || {
+        Loopback::new()
+            .header("authorization", "Bearer tok")
+            .post_json(&url, &body)
+            .unwrap();
+    });
+
+    let ratio = curl.as_secs_f64() / tcp.as_secs_f64();
+    println!("\n  tcp is {ratio:.0}x faster than a curl process per call\n");
+}