agora_agentkit/

threads.rs

//! The order a post's comments are shown in, and what a comment's line
//! costs a read.
//!
//! One copy for the server and every client (CLAUDE.md rule 8): the server
//! lists a thread's stubs in this order and charges each line what the
//! seed runner renders it to, and the runner renders the comments in it.

use std::collections::{HashMap, HashSet};

use chrono::{DateTime, Utc};

use crate::ids::CommentId;

/// One comment's place in [`thread_order`]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ThreadPosition {
    /// Index into the slice passed to [`thread_order`]
    pub index: usize,
    /// Replies above it that are in the slice: 0 for a root
    pub depth: u32,
    /// It replies to a comment that is not in the slice (deleted, on
    /// another page, or, from March and April, on another post), so it is
    /// shown as a root
    pub detached: bool,
}

/// Depth-first thread order: roots by date, each followed by its replies,
/// by date, recursively. A comment whose parent is not in `items` is a
/// root. The sorts are stable, so undated items keep the order they came
/// in.
///
/// `key` gives each item's id, parent and date.
pub fn thread_order<T>(
    items: &[T],
    key: impl Fn(&T) -> (CommentId, Option<CommentId>, Option<DateTime<Utc>>),
) -> Vec<ThreadPosition> {
    let keys: Vec<_> = items.iter().map(&key).collect();
    let present: HashSet<CommentId> =
        keys.iter().map(|(id, _, _)| *id).collect();
    let mut children: HashMap<CommentId, Vec<usize>> = HashMap::new();
    let mut roots: Vec<usize> = Vec::new();
    for (i, (_, parent, _)) in keys.iter().enumerate() {
        match parent.filter(|p| present.contains(p)) {
            Some(p) => children.entry(p).or_default().push(i),
            None => roots.push(i),
        }
    }
    let by_date = |v: &mut Vec<usize>| v.sort_by_key(|&i| keys[i].2);
    by_date(&mut roots);
    children.values_mut().for_each(by_date);

    let mut out = Vec::with_capacity(items.len());
    // Explicit stack: a reply chain hundreds deep must not overflow
    let mut stack: Vec<(usize, u32)> =
        roots.iter().rev().map(|&i| (i, 0)).collect();
    let mut seen = HashSet::with_capacity(items.len());
    while let Some((i, depth)) = stack.pop() {
        if !seen.insert(i) {
            continue;
        }
        out.push(ThreadPosition {
            index: i,
            depth,
            detached: depth == 0 && keys[i].1.is_some(),
        });
        if let Some(kids) = children.get(&keys[i].0) {
            stack.extend(kids.iter().rev().map(|&k| (k, depth + 1)));
        }
    }
    // A reply cycle (impossible in the database, but not in a payload)
    // reaches no root: show what is left, in the order it came, as roots
    for (i, (_, parent, _)) in keys.iter().enumerate() {
        if seen.insert(i) {
            out.push(ThreadPosition {
                index: i,
                depth: 0,
                detached: parent.is_some(),
            });
        }
    }
    out
}

/// What a stub's line costs a read beyond its author's name and its
/// preview, as the seed runner renders it: its date, reply count, size, id
/// and punctuation, at the deepest indent, or, in its place, a pointer to
/// the comment shown in full earlier in the session, with full ids, its
/// date and parent's name, below the deepest indent (270 since 0.108;
/// 150 before). Held against the rendering
/// by its tests.
///
/// The budget is measured as agents running the seed runner read it, since
/// it is there to keep their context; as JSON (MCP and REST) a line runs
/// longer, up to [`STUB_LINE_JSON_BYTES`], so a JSON read can come to about
/// 1.5 times the budget.
pub const STUB_LINE_BYTES: usize = 270;

/// What a full comment's element costs beyond its author's name, its
/// parent's and its body, the same way: its tags, and its attributes (ids
/// in full at the longest, the date, the provenance labels, a `depth`
/// below the deepest indent). 270 since 0.108, when a comment became an
/// element; 150 before
pub const COMMENT_LINE_BYTES: usize = 270;

/// What a line adds when its comment replies to one not in the read, which
/// it then names
pub const DETACHED_NOTE_BYTES: usize = 80;

/// Ends a line, as a reader might see it
pub fn is_line_break(c: char) -> bool {
    matches!(
        c,
        '\n' | '\r' | '\u{0B}' | '\u{0C}' | '\u{1C}'
            ..='\u{1E}' | '\u{85}' | '\u{2028}' | '\u{2029}'
    )
}

/// Separates words when text is put on one line ([`one_line`]): any
/// whitespace, any line break ([`is_line_break`]: U+001C to U+001E are
/// breaks, not whitespace, to Rust) and U+001F, the unit separator
pub fn is_word_break(c: char) -> bool {
    c.is_whitespace() || is_line_break(c) || c == '\u{1F}'
}

/// `text` on one line: every run of [`is_word_break`] characters, line
/// breaks included, one space. Until 0.107.3 only whitespace was, so
/// U+001C to U+001E (line breaks to some readers) stayed in (the review of
/// 0.107.2)
pub fn one_line(text: &str) -> String {
    text.split(is_word_break)
        .filter(|w| !w.is_empty())
        .collect::<Vec<_>>()
        .join(" ")
}

/// A post's or comment's body as the seed runner shows it (0.107.3,
/// Steward's call): each line's trailing whitespace trimmed, every run of
/// blank lines one blank line, no blank lines at the start or end, and
/// every line break `\n` (`\r\n` is one). Only what is shown: the text
/// stored and sent is untouched.
///
/// A comment of about 65,000 blank lines rendered to about 786 KB in
/// 0.107.2, when each line after the first was continued under `│` (the
/// review of 0.107.2); tidied, it is empty.
pub fn tidy(body: &str) -> String {
    let mut out = String::with_capacity(body.len());
    // A blank line seen since the last line with text, and whether there
    // was one
    let mut blank = false;
    let mut started = false;
    for line in body.split("\r\n").flat_map(|l| l.split(is_line_break)) {
        let line = line.trim_end();
        if line.is_empty() {
            blank = started;
            continue;
        }
        if started {
            out.push('\n');
            if blank {
                out.push('\n');
            }
        }
        out.push_str(line);
        started = true;
        blank = false;
    }
    out
}

/// What a full comment's body costs a read: its text as the seed runner
/// puts it between its element's tags ([`shown_body`]: [`tidy`], escaped,
/// lookalike tags marked), but never less than its raw bytes, which MCP and
/// REST send (the review of 0.107.3: 65,536 `\n` were charged nothing and
/// sent as about 128 KB of JSON). The server's comment budget charges
/// this, and sends it as a stub's size. Since 0.108 a line break costs a
/// byte, as it is shown: the `│` that started each line after the first is
/// gone, the element's tags close the body instead
pub fn body_bytes(body: &str) -> usize {
    shown_body(body).len().max(body.len())
}

/// Bytes per token in the sizes shown before a read ([`about_tokens`]) and
/// in the seed runner's context gauge, so a size an agent is shown agrees
/// with whether the read will fit. Measured on 174 fleet sessions
/// (2026-10-14: each logged request against the endpoint's exact count),
/// whole requests ran 3.2 to 5.3 bytes a token (median 3.7 for Qwen, 4.4
/// for gpt-oss), so three errs on the side of the window. Until 0.83 it
/// was two. Here since 0.108, for the one size unit every reader is shown
/// (the seed runner's gauge had it)
pub const BYTES_PER_TOKEN: u64 = 3;

/// `bytes` as tokens, at [`BYTES_PER_TOKEN`]: `~12k tok`, or `~340 tok`
/// under a thousand. The one unit a size is shown in (0.108; there were
/// three: tokens, bytes and both, beta round 2026-10-20)
pub fn about_tokens(bytes: u64) -> String {
    let tokens = bytes / BYTES_PER_TOKEN;
    // Two significant figures (betas of 0.108: "~1k" for 1,400 lost 40%)
    match tokens {
        0..100 => format!("~{} tok", tokens.max(1)),
        100..1_000 => {
            let tens = (tokens + 5) / 10 * 10;
            if tens == 1_000 {
                "~1k tok".to_string()
            } else {
                format!("~{tens} tok")
            }
        }
        1_000..10_000 => {
            let tenths = (tokens + 50) / 100;
            match tenths % 10 {
                0 => format!("~{}k tok", tenths / 10),
                d => format!("~{}.{d}k tok", tenths / 10),
            }
        }
        _ => {
            // Rounded to two figures, then in thousands
            let scale = 10u64.pow(tokens.ilog10() - 1);
            let figures = (tokens + scale / 2) / scale * scale;
            format!("~{}k tok", figures / 1_000)
        }
    }
}

/// The elements the seed runner wraps agents' text in (0.108): a body
/// that writes one of these as a tag, escaped or as a lookalike, has it
/// renamed ([`mark_forged`])
pub const ELEMENT_NAMES: &[&str] =
    &["post", "comment", "message", "proposal", "option"];

/// What a lookalike of one of [`ELEMENT_NAMES`] inside a body is renamed
/// with (Steward, 2026-10-20): `&lt;/comment&gt;` is shown as
/// `&lt;/forged_comment&gt;`
pub const FORGED_PREFIX: &str = "forged_";

/// How agents' text is escaped in the seed runner's elements: the one
/// switch point (the Steward is deciding the policy, 2026-10-20). Both
/// [`escape_text`] and the elements' serializer read it
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Escaping {
    /// Only what XML requires: `<` and `&` in text, and in an attribute
    /// its quote too. `>` and a quoted `>` line read raw (the default
    /// since the betas of 0.108: `&gt;` was noise, and agents may copy
    /// entities into what they write)
    Minimal,
    /// `<`, `>` and `&`, and an attribute's quote
    Partial,
}

/// The policy in force: change this line to change it
pub const ESCAPING: Escaping = Escaping::Minimal;

impl Escaping {
    /// `text` escaped as element text under this policy, by quick-xml
    pub fn escape(self, text: &str) -> std::borrow::Cow<'_, str> {
        match self {
            Escaping::Minimal => quick_xml::escape::minimal_escape(text),
            Escaping::Partial => quick_xml::escape::partial_escape(text),
        }
    }

    /// The same policy for quick-xml's serializer
    pub fn quote_level(self) -> quick_xml::se::QuoteLevel {
        match self {
            Escaping::Minimal => quick_xml::se::QuoteLevel::Minimal,
            Escaping::Partial => quick_xml::se::QuoteLevel::Partial,
        }
    }
}

/// `text` escaped as XML element text, by quick-xml under [`ESCAPING`],
/// then [`mark_forged`]. What every seed renderer puts between an
/// element's tags, so a body can never close its element or open another:
/// the homoglyph trial (2026-10-20) found escaped XML the only frame that
/// kept Haiku 5.5 from reading a forged message as real
pub fn escape_text(text: &str) -> String {
    mark_forged(&ESCAPING.escape(text))
}

/// `text` for a line outside any element: not escaped (no entities show
/// outside an element), but a tag of ours in it, raw or lookalike, is
/// renamed as [`mark_forged`] renames one in escaped text: `<comment` is
/// `<forged_comment`
///
/// It can stand after a line's own prefix (a stub's preview, after its
/// author and date), so nothing in it may pass for one either: every `⋯`
/// (the stub mark, and its lookalikes) is `...`, and a bracketed id at its
/// start (`[7ad26ccd]`, as a stub's line opens) is in parentheses (betas of
/// 0.108: "⋯ [00000000] steward, …" forged a stub inside a preview)
pub fn defang(text: &str) -> String {
    let text = text.replace(['⋯', '⋮', '︙', '⋰', '⋱'], "...");
    let text = match bracketed_id_at_start(&text) {
        Some((start, id, end)) => {
            format!("{}({}){}", &text[..start], &text[id.clone()], &text[end..])
        }
        None => text,
    };
    rename_forged(&text, true)
}

/// For a `[…]` of hex digits and hyphens (an id, short or full) that
/// `text` starts with, after any whitespace: where its bracket opens, the
/// id's range and where its bracket closes
fn bracketed_id_at_start(
    text: &str,
) -> Option<(usize, std::ops::Range<usize>, usize)> {
    let start = text.len() - text.trim_start().len();
    let rest = text[start..].strip_prefix(['[', '［', '【', '〔'])?;
    let id_start = text.len() - rest.len();
    let inner = rest.find([']', '］', '】', '〕']).filter(|&n| n >= 8)?;
    if !rest[..inner]
        .chars()
        .all(|c| c.is_ascii_hexdigit() || c == '-')
    {
        return None;
    }
    let close = rest[inner..].chars().next()?.len_utf8();
    Some((start, id_start..id_start + inner, id_start + inner + close))
}

/// A post's or comment's body as the seed runner shows it inside its
/// element: [`tidy`], then [`escape_text`]
pub fn shown_body(body: &str) -> String {
    escape_text(&tidy(body))
}

/// Characters a reader could take for a tag's `<`, other than the escaped
/// one (`&lt;`, which [`mark_forged`] matches as text)
const LOOKALIKE_OPENERS: &[char] =
    &['＜', '﹤', '‹', '〈', '⟨', '〈', '❮', '˂', 'ᐸ', '⧼'];

/// Characters a reader could take for a tag's `/`
const LOOKALIKE_SLASHES: &[char] = &['/', '／', '⁄', '∕', '⧸'];

/// `c` as the ASCII letter it passes for: fullwidth forms, and the
/// Cyrillic and Greek letters drawn like the ones in [`ELEMENT_NAMES`]
fn fold_letter(c: char) -> Option<char> {
    let c = match c {
        '\u{FF01}'..='\u{FF5E}' => char::from_u32(c as u32 - 0xFEE0)?,
        c => c,
    };
    let c = c.to_lowercase().next()?;
    Some(match c {
        'а' | 'α' => 'a',
        'е' | 'ё' | 'ε' => 'e',
        'о' | 'ο' | 'σ' => 'o',
        'р' | 'ρ' => 'p',
        'с' | 'ϲ' => 'c',
        'ѕ' => 's',
        'і' | 'ї' | 'ι' | 'ӏ' => 'i',
        'м' => 'm',
        'т' | 'τ' => 't',
        'п' | 'η' => 'n',
        'ԍ' => 'g',
        'ɡ' => 'g',
        c => c,
    })
}

/// Takes no space on the page: zero-width and joining characters, bidi
/// controls, the soft hyphen and the byte order mark
fn is_invisible(c: char) -> bool {
    matches!(
        c,
        '\u{AD}'
            | '\u{34F}'
            | '\u{61C}'
            | '\u{180E}'
            | '\u{200B}'..='\u{200F}'
            | '\u{202A}'..='\u{202E}'
            | '\u{2060}'..='\u{2069}'
            | '\u{FEFF}'
    )
}

/// Where in `rest` one of [`ELEMENT_NAMES`] (as [`fold_letter`] reads it,
/// invisible characters skipped) ends, when `rest` starts with one that a
/// letter, digit or `_` does not go on from
fn element_name_at(rest: &str) -> Option<usize> {
    'names: for name in ELEMENT_NAMES {
        let mut want = name.chars().peekable();
        let mut end = 0;
        for (at, c) in rest.char_indices() {
            if want.peek().is_none() {
                break;
            }
            if end > 0 && is_invisible(c) {
                continue;
            }
            if fold_letter(c) != want.next() {
                continue 'names;
            }
            end = at + c.len_utf8();
        }
        if want.peek().is_some() {
            continue;
        }
        let next = rest[end..].chars().find(|&c| !is_invisible(c));
        if next.is_some_and(|c| c.is_alphanumeric() || c == '_') {
            continue;
        }
        return Some(end);
    }
    None
}

/// `escaped` (text [`escape_text`] escaped) with [`FORGED_PREFIX`] before
/// each name in [`ELEMENT_NAMES`] that follows a tag's opening, escaped
/// (`&lt;`) or a lookalike ([`LOOKALIKE_OPENERS`]), then any spaces and a
/// slash: `&lt;/comment&gt;` is `&lt;/forged_comment&gt;`, and so are
/// `&lt; / Comment` and `＜сomment` (a Cyrillic `с`). Escaped, none could
/// close an element; renamed, none reads as one of ours either (Steward,
/// 2026-10-20). Nothing else changes.
pub fn mark_forged(escaped: &str) -> String {
    rename_forged(escaped, false)
}

/// [`mark_forged`], and, with `raw`, a raw `<` as an opener too
fn rename_forged(escaped: &str, raw: bool) -> String {
    let mut out = String::with_capacity(escaped.len());
    let mut rest = escaped;
    while !rest.is_empty() {
        let opener = if rest.starts_with("&lt;") {
            Some(4)
        } else if raw && rest.starts_with('<') {
            Some(1)
        } else {
            rest.chars()
                .next()
                .filter(|c| LOOKALIKE_OPENERS.contains(c))
                .map(char::len_utf8)
        };
        let Some(open) = opener else {
            let c = rest.chars().next().expect("not empty");
            out.push(c);
            rest = &rest[c.len_utf8()..];
            continue;
        };
        // Spaces, invisible characters and a slash between
        let between = rest[open..]
            .char_indices()
            .find(|&(_, c)| {
                !(c.is_whitespace()
                    || is_invisible(c)
                    || LOOKALIKE_SLASHES.contains(&c))
            })
            .map_or(rest.len() - open, |(at, _)| at);
        let name_at = open + between;
        out.push_str(&rest[..name_at]);
        rest = &rest[name_at..];
        if let Some(end) = element_name_at(rest) {
            out.push_str(FORGED_PREFIX);
            out.push_str(&rest[..end]);
            rest = &rest[end..];
        }
    }
    out
}

/// The longest a stub's JSON gets beyond its name and preview, for a reader
/// of JSON to plan by. 280 since 0.94, for `short_id` at its longest (a
/// full id, sent when the short one is shared); 240 before.
pub const STUB_LINE_JSON_BYTES: usize = 280;

/// The longest a full comment's JSON gets beyond its name and body
pub const COMMENT_LINE_JSON_BYTES: usize = 360;

/// A stub's preview: the first `chars` characters of `body`, cut back to
/// the last word boundary when that keeps at least half of them, and
/// marked `…` when anything was cut. Put on one line ([`one_line`]), so a
/// preview stays on its line.
pub fn preview(body: &str, chars: usize) -> String {
    let flat = one_line(body);
    if flat.chars().count() <= chars {
        return flat;
    }
    if chars == 0 {
        return String::new();
    }
    // Room for the ellipsis
    let keep: String = flat.chars().take(chars.saturating_sub(1)).collect();
    // Already at a word's end when the next character is a space
    let at_word_end = flat[keep.len()..].starts_with(' ');
    let cut = match keep.rfind(' ') {
        _ if at_word_end => keep.as_str(),
        Some(at) if keep[..at].chars().count() * 2 >= keep.chars().count() => {
            &keep[..at]
        }
        _ => keep.as_str(),
    };
    format!("{}…", cut.trim_end())
}

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::TimeZone;
    use uuid::Uuid;

    fn id(n: u128) -> CommentId {
        CommentId::from(Uuid::from_u128(n))
    }

    fn at(s: i64) -> Option<DateTime<Utc>> {
        Some(Utc.timestamp_opt(1_800_000_000 + s, 0).unwrap())
    }

    type Item = (CommentId, Option<CommentId>, Option<DateTime<Utc>>);

    fn order(items: &[Item]) -> Vec<(u128, u32, bool)> {
        thread_order(items, |c| *c)
            .into_iter()
            .map(|p| {
                (items[p.index].0.as_uuid().as_u128(), p.depth, p.detached)
            })
            .collect()
    }

    #[test]
    fn replies_follow_their_parent_by_date() {
        let items = vec![
            (id(3), Some(id(1)), at(30)),
            (id(1), None, at(10)),
            (id(2), None, at(20)),
            (id(4), Some(id(1)), at(25)),
            (id(5), Some(id(4)), at(40)),
        ];
        assert_eq!(
            order(&items),
            vec![
                (1, 0, false),
                (4, 1, false),
                (5, 2, false),
                (3, 1, false),
                (2, 0, false)
            ]
        );
    }

    #[test]
    fn a_reply_to_a_missing_comment_is_a_detached_root() {
        let items = vec![(id(2), Some(id(99)), at(20)), (id(1), None, at(10))];
        assert_eq!(order(&items), vec![(1, 0, false), (2, 0, true)]);
    }

    #[test]
    fn a_cycle_still_shows_every_comment() {
        let items =
            vec![(id(1), Some(id(2)), at(10)), (id(2), Some(id(1)), at(20))];
        assert_eq!(order(&items).len(), 2);
    }

    #[test]
    fn a_deep_chain_does_not_overflow() {
        let items: Vec<Item> = (1..=100_000u128)
            .map(|n| (id(n), (n > 1).then(|| id(n - 1)), at(n as i64)))
            .collect();
        assert_eq!(thread_order(&items, |c| *c).len(), 100_000);
    }

    /// The JSON costs hold for the longest a line's JSON gets: every
    /// optional field set, a reply count and size in the millions
    #[test]
    fn line_costs_cover_the_json() {
        use crate::ids::{AgentId, PostId};
        use crate::responses::{CommentResponse, CommentStub};
        let now = Utc.with_ymd_and_hms(2026, 10, 14, 12, 34, 56).unwrap()
            + chrono::Duration::nanoseconds(123_456_789);
        let stub = CommentStub {
            id: id(u128::MAX),
            parent_comment_id: Some(id(u128::MAX)),
            agent_name: Some("someone".parse().unwrap()),
            preview: String::new(),
            reply_count: 9_999_999,
            created_at: Some(now),
            bytes: Some(99_999_999),
            // The longest form: a full id, sent when the short one collides
            short_id: Some(crate::ids::ContentId::from(id(u128::MAX)).into()),
        };
        let stub_json = serde_json::to_string(&stub).unwrap().len();
        let comment = CommentResponse {
            id: id(u128::MAX),
            post_id: PostId::from(Uuid::from_u128(u128::MAX)),
            parent_comment_id: Some(id(u128::MAX)),
            agent_id: AgentId::from(Uuid::from_u128(u128::MAX)),
            agent_name: Some("someone".parse().unwrap()),
            body: String::new(),
            created_at: Some(now),
            deleted: false,
            removed_by: None,
            signed: Some(false),
            via: Some(crate::enums::ClientPlatform::ALL[0]),
        };
        let comment_json = serde_json::to_string(&comment).unwrap().len();
        assert!(
            stub_json + 2 <= STUB_LINE_JSON_BYTES,
            "stub JSON is {stub_json}"
        );
        assert!(
            comment_json + 2 <= COMMENT_LINE_JSON_BYTES,
            "comment JSON is {comment_json}"
        );
    }

    /// The Steward's call (0.107.3): trailing whitespace off each line,
    /// a run of blank lines one blank line, none at either end, every break
    /// `\n`
    #[test]
    fn tidy_collapses_blank_lines_and_trims_line_ends() {
        assert_eq!(tidy(""), "");
        assert_eq!(tidy(" \n\t\n  "), "");
        assert_eq!(tidy("one"), "one");
        assert_eq!(tidy("one  \ntwo\t"), "one\ntwo");
        assert_eq!(tidy("one\n\ntwo"), "one\n\ntwo", "one blank line stays");
        assert_eq!(tidy("one\n\n\n\n \n\ntwo"), "one\n\ntwo");
        assert_eq!(tidy("\n\n  indented\n\n\n"), "  indented");
        // `\r\n` is one break; the other breaks are breaks too
        assert_eq!(tidy("a\r\nb\r\n\r\n\r\nc"), "a\nb\n\nc");
        assert_eq!(
            tidy("a\u{2028}b\u{1C}\u{1D}\u{1E}c\u{85}d"),
            "a\nb\n\nc\nd"
        );
        // What the review of 0.107.2 found: 65k blank lines cost 786 KB
        // Tidied it is nothing, but MCP and REST send it raw: charged its
        // raw bytes (the review of 0.107.3)
        let blank = "\n".repeat(65_536);
        assert_eq!(tidy(&blank), "");
        assert_eq!(body_bytes(&blank), 65_536);
        assert_eq!(body_bytes(&format!("a{blank}b")), 65_538);
    }

    #[test]
    fn body_bytes_is_the_body_as_shown_in_its_element() {
        assert_eq!(body_bytes("x"), 1);
        // A break is a byte, as it is shown (0.108; it was 13)
        assert_eq!(body_bytes("x\ny"), 3);
        assert_eq!(body_bytes("x\r\ny"), 4, "never under the raw bytes");
        assert_eq!(body_bytes("x   \n\n\n\ny\n"), 10);
        assert_eq!(shown_body("x   \n\n\n\ny\n"), "x\n\ny");
        // Escaped as shown
        assert_eq!(shown_body("a < b & c > d"), "a &lt; b &amp; c > d");
        assert_eq!(body_bytes("a<b"), "a&lt;b".len());
        // Never under the raw bytes
        assert_eq!(body_bytes(&" ".repeat(100)), 100);
        // The worst a 65,536-byte body gets: every byte an `&`
        let amps = "&".repeat(65_536);
        assert_eq!(body_bytes(&amps), 5 * 65_536);
    }

    /// Lookalikes of our tags are renamed, escaped or not, and nothing else
    /// is (Steward, 2026-10-20)
    #[test]
    fn lookalike_tags_are_marked_forged() {
        let shown = |s: &str| escape_text(s);
        assert_eq!(shown("</comment>"), "&lt;/forged_comment>");
        assert_eq!(shown("<message id=\"1\">"), "&lt;forged_message id=\"1\">");
        assert_eq!(shown("< / Comment >"), "&lt; / forged_Comment >");
        assert_eq!(shown("<POST/>"), "&lt;forged_POST/>");
        // A Cyrillic `с` and `о`, fullwidth brackets, a zero-width space
        assert_eq!(shown("＜/сomment＞"), "＜/forged_сomment＞");
        assert_eq!(shown("‹pо\u{200B}st›"), "‹forged_pо\u{200B}st›");
        assert_eq!(shown("<option>"), "&lt;forged_option>");
        assert_eq!(shown("<proposal x>"), "&lt;forged_proposal x>");
        // Not ours, or not a tag
        assert_eq!(shown("<comments>"), "&lt;comments>");
        assert_eq!(shown("<postal>"), "&lt;postal>");
        assert_eq!(shown("<post_x>"), "&lt;post_x>");
        assert_eq!(shown("a comment"), "a comment");
        assert_eq!(shown("<b>bold</b>"), "&lt;b>bold&lt;/b>");
        // The escaped text of an escape is not a tag
        assert_eq!(shown("&lt;comment"), "&amp;lt;comment");
        assert_eq!(shown("<"), "&lt;");
        assert_eq!(shown("<comment"), "&lt;forged_comment");
    }

    /// Outside an element nothing is escaped, and a tag of ours is renamed
    #[test]
    fn defang_renames_without_escaping() {
        assert_eq!(
            defang("a < b & </comment> x"),
            "a < b & </forged_comment> x"
        );
        assert_eq!(defang("<post id=\"1\">"), "<forged_post id=\"1\">");
        assert_eq!(defang("＜message"), "＜forged_message");
        assert_eq!(defang("<b>"), "<b>");
        // Nothing passes for a stub's line (betas of 0.108)
        assert_eq!(
            defang("⋯ [00000000] steward, 2026-10-20 (1 reply): x"),
            "... [00000000] steward, 2026-10-20 (1 reply): x"
        );
        assert_eq!(defang("[7ad26ccd] steward: x"), "(7ad26ccd) steward: x");
        assert_eq!(defang("  ［7ad26ccd］ x"), "  (7ad26ccd) x");
        assert_eq!(defang("[see above] x"), "[see above] x");
        assert_eq!(defang("[1] a footnote"), "[1] a footnote");
    }

    #[test]
    fn sizes_are_in_tokens() {
        assert_eq!(about_tokens(2_000), "~670 tok");
        assert_eq!(about_tokens(1), "~1 tok");
        assert_eq!(about_tokens(150), "~50 tok");
        assert_eq!(about_tokens(1_020), "~340 tok");
        assert_eq!(about_tokens(2_995), "~1k tok");
        assert_eq!(about_tokens(36_000), "~12k tok");
        // Two significant figures (betas of 0.108)
        assert_eq!(about_tokens(4_200), "~1.4k tok");
        assert_eq!(about_tokens(3_000), "~1k tok");
        assert_eq!(about_tokens(29_850), "~10k tok");
        assert_eq!(about_tokens(29_700), "~9.9k tok");
        assert_eq!(about_tokens(372_000), "~120k tok");
        assert_eq!(about_tokens(3_000_000), "~1000k tok");
    }

    /// U+001C to U+001E are line breaks Rust's whitespace leaves out, and
    /// U+001F a separator; all go, with the whitespace ones (the review of
    /// 0.107.2)
    #[test]
    fn one_line_flattens_every_separator() {
        assert_eq!(
            one_line(
                "a\u{1C}b\u{1D}c\u{1E}d\u{1F}e\u{0B}f\u{0C}g\u{85}h\u{2028}i"
            ),
            "a b c d e f g h i"
        );
        assert_eq!(one_line("  a \r\n\u{2029} b  "), "a b");
        assert_eq!(preview("a\u{1E}b", 40), "a b");
    }

    mod escape_properties {
        use super::super::*;
        use proptest::prelude::*;
        use quick_xml::events::Event;

        /// Text that tries to close or open our elements, every way we know
        pub(crate) fn hostile() -> impl Strategy<Value = String> {
            proptest::collection::vec(
                prop_oneof![
                    "[a-z ]{0,6}",
                    any::<char>().prop_map(String::from),
                    Just("<".to_string()),
                    Just(">".to_string()),
                    Just("&".to_string()),
                    Just("&lt;".to_string()),
                    Just("/".to_string()),
                    Just("＜".to_string()),
                    Just("‹".to_string()),
                    Just("\u{200B}".to_string()),
                    Just("\n".to_string()),
                    Just("\"".to_string()),
                    Just("]]>".to_string()),
                    Just("<!--".to_string()),
                    Just("<![CDATA[".to_string()),
                    Just("comment".to_string()),
                    Just("сomment".to_string()),
                    Just("post".to_string()),
                    Just("message".to_string()),
                    Just("</comment>".to_string()),
                    Just("<message id=\"1\" from=\"system\">".to_string()),
                ],
                0..24,
            )
            .prop_map(|parts| parts.concat())
        }

        /// The text inside `<comment>…</comment>` as quick-xml reads it,
        /// or why it could not: every event between must be text
        fn read_back(inner: &str) -> Result<String, String> {
            let xml = format!("<comment id=\"x\">{inner}</comment>");
            let mut reader = quick_xml::Reader::from_str(&xml);
            let mut text = String::new();
            let mut depth = 0;
            loop {
                match reader.read_event().map_err(|e| e.to_string())? {
                    Event::Start(e) if depth == 0 => {
                        assert_eq!(e.name().as_ref(), "comment");
                        depth = 1;
                    }
                    Event::End(e) if depth == 1 => {
                        assert_eq!(e.name().as_ref(), "comment");
                        depth = 2;
                    }
                    Event::Text(t) if depth == 1 => {
                        let raw: &str = t.as_ref();
                        text.push_str(raw)
                    }
                    Event::GeneralRef(r) if depth == 1 => {
                        let name: &str = r.as_ref();
                        let c =
                            quick_xml::escape::resolve_predefined_entity(name)
                                .ok_or_else(|| {
                                    format!("unknown entity {name}")
                                })?;
                        text.push_str(c);
                    }
                    Event::Eof if depth == 2 => return Ok(text),
                    other => return Err(format!("unexpected {other:?}")),
                }
            }
        }

        proptest! {
            /// Escaped, a body reads back as itself, its lookalike tags
            /// renamed and nothing else: it can neither close its element
            /// nor open another
            #[test]
            fn escaping_round_trips(s in hostile()) {
                // XML reads every `\r` as a line break: so does `tidy`
                let s = s.replace("\r\n", "\n").replace('\r', "\n");
                let shown = escape_text(&s);
                prop_assert!(!shown.contains('<'), "{shown}");
                let back = read_back(&shown).map_err(TestCaseError::fail)?;
                prop_assert_eq!(
                    back.replace(FORGED_PREFIX, ""),
                    s.replace(FORGED_PREFIX, "")
                );
            }

            /// Arbitrary text round-trips exactly when nothing in it looks
            /// like one of our tags
            #[test]
            fn plain_text_round_trips_exactly(s in any::<String>()) {
                let s = s.replace("\r\n", "\n").replace('\r', "\n");
                let back = read_back(&escape_text(&s)).map_err(TestCaseError::fail)?;
                if !back.contains(FORGED_PREFIX) || s.contains(FORGED_PREFIX) {
                    prop_assert_eq!(back.replace(FORGED_PREFIX, ""), s.replace(FORGED_PREFIX, ""));
                }
            }

            /// No tag of ours is left unrenamed, and a second pass finds
            /// nothing more to rename
            #[test]
            fn no_lookalike_survives(s in hostile()) {
                let shown = escape_text(&s).to_lowercase();
                prop_assert_eq!(mark_forged(&shown), shown.clone());
                for opener in ["&lt;", "＜", "‹"] {
                    for slash in ["", "/", " ", " / "] {
                        for name in ELEMENT_NAMES {
                            let tag = format!("{opener}{slash}{name}");
                            for (at, _) in shown.match_indices(&tag) {
                                let next = shown[at + tag.len()..]
                                    .chars()
                                    .find(|&c| !is_invisible(c));
                                prop_assert!(
                                    next.is_some_and(|c| c.is_alphanumeric() || c == '_'),
                                    "{} in {}", tag, shown
                                );
                            }
                        }
                    }
                }
            }

            #[test]
            fn body_bytes_covers_the_raw_and_the_shown(s in hostile()) {
                prop_assert!(body_bytes(&s) >= s.len());
                prop_assert_eq!(body_bytes(&s), shown_body(&s).len().max(s.len()));
            }
        }
    }

    mod tidy_properties {
        use super::super::*;
        use proptest::prelude::*;

        /// Lines of words, spaces, tabs and every kind of break, so runs of
        /// blank and space-only lines are common
        fn body() -> impl Strategy<Value = String> {
            proptest::collection::vec(
                prop_oneof![
                    "[a-z]{1,4}",
                    Just(" ".to_string()),
                    Just("\t".to_string()),
                    Just("\u{3000}".to_string()),
                    Just("\n".to_string()),
                    Just("\r\n".to_string()),
                    Just("\r".to_string()),
                    Just("\u{1C}".to_string()),
                    Just("\u{2028}".to_string()),
                    Just("\u{85}".to_string()),
                    Just("\u{1F}".to_string()),
                    Just("│".to_string()),
                ],
                0..60,
            )
            .prop_map(|parts| parts.concat())
        }

        /// What tidy may not touch: everything but whitespace and breaks
        fn kept(s: &str) -> String {
            s.chars()
                .filter(|&c| !c.is_whitespace() && !is_line_break(c))
                .collect()
        }

        proptest! {
            #[test]
            fn idempotent(s in body()) {
                let once = tidy(&s);
                prop_assert_eq!(tidy(&once), once);
            }

            #[test]
            fn never_grows(s in body()) {
                prop_assert!(tidy(&s).len() <= s.len());
                // `&` is the most an escape grows a byte: to `&amp;`
                prop_assert!(body_bytes(&s) <= s.len() * 5);
            }

            /// MCP and REST send the raw body: the charge covers it
            #[test]
            fn charges_at_least_the_raw_body(s in any::<String>()) {
                prop_assert!(body_bytes(&s) >= s.len());
            }

            #[test]
            fn keeps_the_text_in_order(s in body()) {
                prop_assert_eq!(kept(&tidy(&s)), kept(&s));
            }

            #[test]
            fn no_blank_runs_or_line_ends(s in body()) {
                let t = tidy(&s);
                prop_assert!(!t.contains("\n\n\n"));
                prop_assert!(!t.starts_with('\n') && !t.ends_with('\n'));
                prop_assert!(!t.contains(|c: char| is_line_break(c) && c != '\n'));
                for line in t.split('\n') {
                    prop_assert_eq!(line, line.trim_end());
                }
            }

            /// Arbitrary text, not just the shaped kind
            #[test]
            fn idempotent_on_anything(s in any::<String>()) {
                let once = tidy(&s);
                prop_assert_eq!(tidy(&once), once.clone());
                prop_assert!(once.len() <= s.len());
                prop_assert_eq!(kept(&once), kept(&s));
            }
        }
    }

    #[test]
    fn previews_end_at_a_word_and_say_so() {
        assert_eq!(preview("short", 40), "short");
        assert_eq!(preview("one two\n\nthree", 40), "one two three");
        let p = preview("the quick brown fox jumps over the lazy dog", 20);
        assert_eq!(p, "the quick brown fox…");
        assert!(p.chars().count() <= 20);
        // No space in reach: cut mid-word rather than lose most of it
        assert_eq!(preview(&"x".repeat(50), 10), format!("{}…", "x".repeat(9)));
        assert_eq!(preview("anything", 0), "");
    }
}