Rebuild: edge-bench-rs, the edge worker's indexing in Rust, for comparison

The RangeIndexer path of edge:bench (inflate, scan, owner rule, segments,
file aggregation, cut-off, rules, release identity, chunk encoding v2,
probe candidates) as a Rust binary over a captured range, with JS
semantics where they matter (\s, trim, \b, parseInt, lastIndexOf, UTF-16
lengths). check.ts runs the TypeScript RangeIndexer on the same capture
and compares every output: identical on all three captures (releases and
their decoded payloads, samples, candidates, rule counts, fragments),
after mapping Date headers ending in UTC to GMT (chrono follows RFC
5322; Date.parse takes UTC, a quarter of a.b.boneless). Compressed
payloads differ by <0.1% in size (zstd framing), not in content.

First run on boneless 2026: 360k headers/s and 228 MB peak (TypeScript:
~217k/s, ~0.7-0.8 GB).

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

tools/edge-bench-rs/src/codec.rs

@@ -0,0 +1,161 @@
+//! lib/chunks/codec.ts encodeChunk, format v2: a version byte, the length of
+//! the compressed part, zstd(JSON head + text ids), then the nyuu and hex ids
+//! as raw bytes.
+
+use crate::js::json_str;
+
+pub struct ChunkFile<'a> {
+    pub name: &'a str,
+    pub poster: &'a str,
+    pub subject: &'a str,
+    pub posted_at: Option<i64>,
+    pub groups: &'a [String],
+    /// [part, message-id, bytes]
+    pub segments: Vec<(u32, &'a str, i64)>,
+}
+
+fn is_nyuu(id: &str, suffix: &str) -> bool {
+    let b = id.as_bytes();
+    if b.len() != 38 + suffix.len() || b[24] != b'-' || !id.ends_with(suffix) {
+        return false;
+    }
+    (0..24).step_by(2).all(|i| b[i].is_ascii_uppercase() && b[i + 1].is_ascii_lowercase()) && b[25..38].iter().all(u8::is_ascii_digit)
+}
+
+fn is_hex(id: &str, suffix: &str) -> bool {
+    let b = id.as_bytes();
+    b.len() == 32 + suffix.len() && id.ends_with(suffix) && b[..32].iter().all(|c| c.is_ascii_digit() || (b'a'..=b'f').contains(c))
+}
+
+fn pack_letters(id: &[u8], out: &mut Vec<u8>) {
+    let mut acc: u32 = 0;
+    let mut bits = 0;
+    for i in (0..24).step_by(2) {
+        acc = (acc << 10) | ((id[i] - b'A') as u32 * 26 + (id[i + 1] - b'a') as u32);
+        bits += 10;
+        while bits >= 8 {
+            bits -= 8;
+            out.push(((acc >> bits) & 0xff) as u8);
+        }
+        acc &= (1 << bits) - 1;
+    }
+}
+
+fn hex_val(c: u8) -> u8 {
+    if c.is_ascii_digit() {
+        c - b'0'
+    } else {
+        c - b'a' + 10
+    }
+}
+
+fn push_num(out: &mut String, n: i64) {
+    use std::fmt::Write;
+    write!(out, "{n}").unwrap();
+}
+
+pub fn encode_chunk(files: &[ChunkFile]) -> Vec<u8> {
+    let mut head = String::with_capacity(256 * files.len());
+    let mut text: Vec<&str> = Vec::new();
+    let mut raw: Vec<u8> = Vec::new();
+    head.push('[');
+    for (fi, f) in files.iter().enumerate() {
+        let ids = &f.segments;
+        let code = match ids.first() {
+            None => 't',
+            Some(&(_, first, _)) => {
+                let nyuu = first.get(38..).filter(|s| s.starts_with('@'));
+                let hex = first.get(32..).filter(|s| s.starts_with('@'));
+                if nyuu.is_some_and(|suffix| ids.iter().all(|&(_, id, _)| is_nyuu(id, suffix))) {
+                    'n'
+                } else if hex.is_some_and(|suffix| ids.iter().all(|&(_, id, _)| is_hex(id, suffix))) {
+                    'h'
+                } else {
+                    't'
+                }
+            }
+        };
+        if fi > 0 {
+            head.push(',');
+        }
+        head.push_str("{\"n\":");
+        json_str(f.name, &mut head);
+        head.push_str(",\"p\":");
+        json_str(f.poster, &mut head);
+        head.push_str(",\"j\":");
+        json_str(f.subject, &mut head);
+        head.push_str(",\"d\":");
+        match f.posted_at {
+            Some(t) => push_num(&mut head, t),
+            None => head.push_str("null"),
+        }
+        head.push_str(",\"g\":[");
+        for (i, g) in f.groups.iter().enumerate() {
+            if i > 0 {
+                head.push(',');
+            }
+            json_str(g, &mut head);
+        }
+        head.push_str("],\"s\":[");
+        for (i, &(_, _, b)) in ids.iter().enumerate() {
+            if i > 0 {
+                head.push(',');
+            }
+            push_num(&mut head, b);
+        }
+        head.push(']');
+        if !ids.iter().enumerate().all(|(k, &(n, _, _))| n as usize == k + 1) {
+            head.push_str(",\"k\":[");
+            for (i, &(n, _, _)) in ids.iter().enumerate() {
+                if i > 0 {
+                    head.push(',');
+                }
+                push_num(&mut head, n as i64);
+            }
+            head.push(']');
+        }
+        match code {
+            'n' => {
+                head.push_str(",\"c\":\"n\",\"x\":");
+                json_str(&ids[0].1[38..], &mut head);
+                head.push_str(",\"t\":[");
+                let mut previous = 0i64;
+                for (i, &(_, id, _)) in ids.iter().enumerate() {
+                    pack_letters(id.as_bytes(), &mut raw);
+                    let t: i64 = id[25..38].parse().unwrap();
+                    if i > 0 {
+                        head.push(',');
+                    }
+                    push_num(&mut head, t - previous);
+                    previous = t;
+                }
+                head.push(']');
+            }
+            'h' => {
+                head.push_str(",\"c\":\"h\",\"x\":");
+                json_str(&ids[0].1[32..], &mut head);
+                for &(_, id, _) in ids {
+                    let b = id.as_bytes();
+                    for i in (0..32).step_by(2) {
+                        raw.push(hex_val(b[i]) << 4 | hex_val(b[i + 1]));
+                    }
+                }
+            }
+            _ => text.extend(ids.iter().map(|&(_, id, _)| id)),
+        }
+        head.push('}');
+    }
+    head.push(']');
+    let mut plain = head.into_bytes();
+    for id in text {
+        plain.push(b'\n');
+        plain.extend_from_slice(id.as_bytes());
+    }
+    let packed = zstd::bulk::compress(&plain, 3).unwrap();
+    let mut out = Vec::with_capacity(5 + packed.len() + raw.len());
+    out.push(2);
+    out.extend_from_slice(&(packed.len() as u32).to_be_bytes());
+    out.extend_from_slice(&packed);
+    out.extend_from_slice(&raw);
+    out
+}

tools/edge-bench-rs/src/indexer.rs

@@ -0,0 +1,601 @@
+//! lib/edge/scan.ts (SegmentScanner, scanOverviewText), lib/files/aggregator.ts
+//! and lib/edge/range_indexer.ts (RangeIndexer, chunkOf, candidatesOf), in the
+//! same order of operations, so the outputs can be compared one to one.
+
+use crate::codec::{encode_chunk, ChunkFile};
+use crate::js::{self, sha1_hex};
+use crate::names::{self, is_random_file, JudgedFile, Release, Verdict};
+use rustc_hash::{FxHashMap, FxHashSet};
+use std::rc::Rc;
+
+pub struct FileMeta {
+    pub file_key: String,
+    pub name: String,
+    pub poster: String,
+    pub subject: String,
+    pub total_parts: u32,
+    pub groups: Vec<String>,
+    pub release: Release,
+}
+
+pub struct Seg {
+    pub file: Rc<FileMeta>,
+    pub number: u32,
+    pub message_id: String,
+    pub bytes: i64,
+    pub article: i64,
+    pub posted_at: Option<i64>,
+}
+
+pub struct ReleaseChunk {
+    pub key: String,
+    pub name: String,
+    pub source: &'static str,
+    pub file_total: Option<i64>,
+    pub poster: String,
+    pub groups: Vec<String>,
+    pub posted_at: Option<i64>,
+    pub files: usize,
+    pub segments: usize,
+    pub bytes: i64,
+    pub first_article: i64,
+    pub last_article: i64,
+    pub readable: bool,
+    pub has_par2: bool,
+    pub payload: Vec<u8>,
+}
+
+pub struct Candidate {
+    pub release_key: String,
+    pub kind: &'static str,
+    pub message_id: String,
+    pub file: String,
+}
+
+pub struct Fragment {
+    pub file_key: String,
+    pub name: String,
+    pub total_parts: u32,
+    pub posted_at: Option<i64>,
+    pub segments: Vec<(u32, String, i64, i64)>,
+}
+
+#[derive(Default)]
+pub struct Batch {
+    pub from: i64,
+    pub next: i64,
+    pub headers: u64,
+    pub releases: Vec<ReleaseChunk>,
+    pub samples: Vec<(ReleaseChunk, &'static str, String)>,
+    pub candidates: Vec<Candidate>,
+    /// (rule, key) → (articles, files)
+    pub counts: Vec<(&'static str, String, u64, u64)>,
+    pub fragments: Vec<Fragment>,
+}
+
+struct Counter {
+    index: usize,
+    length: usize,
+    segment: i64,
+    total: i64,
+}
+
+/// The last "(k/N)" after `after`, scanning back from the end (findCounter).
+fn find_counter(subject: &[u8], after: usize) -> Option<Counter> {
+    let mut open = subject.len();
+    loop {
+        // lastIndexOf('(', open - 1): at most open - 1.
+        if open == 0 {
+            return None;
+        }
+        open = subject[..open].iter().rposition(|&c| c == b'(')?;
+        if open <= after {
+            return None;
+        }
+        let mut i = open + 1;
+        let mut segment: i64 = 0;
+        let mut digits = 0;
+        while let Some(c) = subject.get(i).filter(|c| c.is_ascii_digit()) {
+            segment = segment * 10 + (c - b'0') as i64;
+            digits += 1;
+            i += 1;
+        }
+        if digits == 0 || subject.get(i) != Some(&b'/') {
+            continue;
+        }
+        i += 1;
+        let mut total: i64 = 0;
+        digits = 0;
+        while let Some(c) = subject.get(i).filter(|c| c.is_ascii_digit()) {
+            total = total * 10 + (c - b'0') as i64;
+            digits += 1;
+            i += 1;
+        }
+        if digits == 0 || subject.get(i) != Some(&b')') {
+            continue;
+        }
+        return Some(Counter { index: open, length: i + 1 - open, segment, total });
+    }
+}
+
+fn xref_groups(xref: &str, group: &str) -> Vec<String> {
+    let mut groups = Vec::new();
+    for token in js::split_spaces(js::trim(xref)).into_iter().skip(1) {
+        if let Some(colon) = token.rfind(':') {
+            if colon > 0 {
+                groups.push(token[..colon].to_string());
+            }
+        }
+    }
+    if groups.is_empty() {
+        groups.push(group.to_string());
+    }
+    groups
+}
+
+#[derive(Default)]
+struct Scanner {
+    files: FxHashMap<String, Option<Rc<FileMeta>>>,
+    key: String,
+}
+
+impl Scanner {
+    fn owner<'a>(&self, xref: &'a str, group: &'a str, priorities: &FxHashMap<String, u32>) -> &'a str {
+        let b = xref.as_bytes();
+        let Some(mut at) = xref.find(' ') else { return group };
+        let mut owner: Option<&str> = None;
+        let mut best = u32::MAX;
+        loop {
+            while b.get(at) == Some(&b' ') {
+                at += 1;
+            }
+            if at >= b.len() {
+                break;
+            }
+            let end = xref[at..].find(' ').map(|i| i + at);
+            // lastIndexOf(':', end ?? length): a colon at or before `end`.
+            let limit = end.unwrap_or(b.len());
+            let colon = xref[..limit.min(b.len())].rfind(':');
+            if let Some(colon) = colon.filter(|&c| c > at) {
+                let name = &xref[at..colon];
+                if let Some(&p) = priorities.get(name) {
+                    if p < best {
+                        best = p;
+                        owner = Some(name);
+                    }
+                }
+            }
+            match end {
+                Some(e) => at = e,
+                None => break,
+            }
+        }
+        owner.unwrap_or(group)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn segment(&mut self, article: i64, subject: &str, from: &str, date: &str, message_id: &str, bytes: &str, xref: &str, group: &str) -> Option<Seg> {
+        if subject.is_empty() || message_id.is_empty() {
+            return None;
+        }
+        let sb = subject.as_bytes();
+        let name_end = subject.rfind('"')?;
+        if name_end == 0 {
+            return None;
+        }
+        let counter = find_counter(sb, name_end)?;
+        self.key.clear();
+        self.key.push_str(from);
+        self.key.push('\u{1}');
+        self.key.push_str(&subject[..counter.index]);
+        self.key.push('\u{0}');
+        self.key.push_str(&subject[counter.index + counter.length..]);
+        let file = match self.files.get(self.key.as_str()) {
+            Some(f) => f.clone(),
+            None => {
+                let f = describe(subject, name_end, &counter, from, xref, group).map(Rc::new);
+                self.files.insert(self.key.clone(), f.clone());
+                f
+            }
+        };
+        let file = file?;
+        if counter.segment < 1 || counter.segment > file.total_parts as i64 {
+            return None;
+        }
+        let id = if message_id.starts_with('<') { message_id.get(1..message_id.len().saturating_sub(1)).unwrap_or("") } else { message_id };
+        Some(Seg {
+            number: counter.segment as u32,
+            message_id: id.to_string(),
+            bytes: js::parse_int(bytes).unwrap_or(0),
+            article,
+            posted_at: js::parse_date(date),
+            file,
+        })
+    }
+}
+
+fn describe(subject: &str, name_end: usize, counter: &Counter, from: &str, xref: &str, group: &str) -> Option<FileMeta> {
+    let name_start = subject[..name_end].rfind('"')?;
+    let name = &subject[name_start + 1..name_end];
+    if name.is_empty() || counter.total < 1 {
+        return None;
+    }
+    let joined = format!("{}{}", &subject[..counter.index], &subject[counter.index + counter.length..]);
+    let base = js::trim(&js::collapse_spaces(&joined)).to_string();
+    let file_key = sha1_hex(&format!("{from}\n{base}\n{}", counter.total));
+    let release = names::release_identity(from, &base, name);
+    Some(FileMeta {
+        file_key,
+        name: name.to_string(),
+        poster: from.to_string(),
+        subject: base,
+        total_parts: counter.total as u32,
+        groups: xref_groups(xref, group),
+        release,
+    })
+}
+
+/// One line of an XOVER reply: number, subject, from, date, message-id, bytes, xref (scanOverviewText).
+fn scan_overview_text(text: &str, mut line: impl FnMut(Option<i64>, &str, &str, &str, &str, &str, &str)) {
+    let b = text.as_bytes();
+    let mut start = 0;
+    while start < b.len() {
+        let end = memchr(b'\n', &b[start..]).map(|i| i + start).unwrap_or(b.len());
+        let stop = if end > start && b[end - 1] == b'\r' { end - 1 } else { end };
+        if stop > start {
+            let l = &text[start..stop];
+            let lb = l.as_bytes();
+            let mut tabs = [usize::MAX; 9];
+            let mut n = 0;
+            for (i, &c) in lb.iter().enumerate() {
+                if c == b'\t' {
+                    tabs[n] = i;
+                    n += 1;
+                    if n == 9 {
+                        break;
+                    }
+                }
+            }
+            if n >= 5 {
+                let field = |a: usize, b: usize| -> &str {
+                    if a == usize::MAX {
+                        ""
+                    } else {
+                        &l[a + 1..if b == usize::MAX { l.len() } else { b }]
+                    }
+                };
+                let mut xref = if n >= 8 { field(tabs[7], tabs[8]) } else { "" };
+                if let Some(rest) = xref.strip_prefix("Xref:") {
+                    xref = rest.strip_prefix(' ').unwrap_or(rest);
+                }
+                line(js::parse_int(&l[..tabs[0]]), &l[tabs[0] + 1..tabs[1]], field(tabs[1], tabs[2]), field(tabs[2], tabs[3]), field(tabs[3], tabs[4]), field(tabs[5], tabs[6]), xref);
+            }
+        }
+        start = end + 1;
+    }
+}
+
+fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> {
+    haystack.iter().position(|&c| c == needle)
+}
+
+struct OpenFile {
+    parts: Vec<Seg>,
+    seen: FxHashSet<u32>,
+    total: u32,
+    touched: u64,
+}
+
+#[derive(Default)]
+struct Aggregator {
+    open: FxHashMap<String, OpenFile>,
+    batch: u64,
+}
+
+impl Aggregator {
+    fn add(&mut self, segments: Vec<Seg>) -> Vec<Vec<Seg>> {
+        self.batch += 1;
+        let mut touched: Vec<String> = Vec::new();
+        let mut touched_set: FxHashSet<String> = FxHashSet::default();
+        for s in segments {
+            let key = &s.file.file_key;
+            let file = match self.open.get_mut(key.as_str()) {
+                Some(f) => f,
+                None => self.open.entry(key.clone()).or_insert(OpenFile { parts: Vec::new(), seen: FxHashSet::default(), total: s.file.total_parts, touched: self.batch }),
+            };
+            if !touched_set.contains(key.as_str()) {
+                touched_set.insert(key.clone());
+                touched.push(key.clone());
+            }
+            file.touched = self.batch;
+            if file.seen.insert(s.number) {
+                file.parts.push(s);
+            }
+        }
+        let mut complete = Vec::new();
+        for key in touched {
+            let f = self.open.get(&key).unwrap();
+            if (f.parts.len() as u32) < f.total {
+                continue;
+            }
+            let mut f = self.open.remove(&key).unwrap();
+            f.parts.sort_by_key(|s| s.number);
+            complete.push(f.parts);
+        }
+        complete
+    }
+
+    /// Files idle for `idle` batches (all when 0): their segments, file by file in arrival order.
+    fn evict(&mut self, idle: u64) -> Vec<Vec<Seg>> {
+        let batch = self.batch;
+        let gone: Vec<String> = self.open.iter().filter(|(_, f)| !(idle > 0 && batch - f.touched < idle)).map(|(k, _)| k.clone()).collect();
+        gone.into_iter().map(|k| self.open.remove(&k).unwrap().parts).collect()
+    }
+}
+
+pub struct RangeIndexer {
+    group: String,
+    start: i64,
+    end: i64,
+    priorities: FxHashMap<String, u32>,
+    idle: u64,
+    chunk_articles: i64,
+    scanner: Scanner,
+    aggregator: Aggregator,
+    batch: Batch,
+    counts: FxHashMap<(&'static str, String), (u64, u64)>,
+    count_order: Vec<(&'static str, String)>,
+    completed: FxHashMap<String, Vec<Vec<Seg>>>,
+    completed_order: Vec<String>,
+}
+
+impl RangeIndexer {
+    pub fn new(group: &str, start: i64, end: i64, priorities: FxHashMap<String, u32>, idle: u64) -> Self {
+        RangeIndexer {
+            group: group.to_string(),
+            start,
+            end,
+            priorities,
+            idle,
+            chunk_articles: 0,
+            scanner: Scanner::default(),
+            aggregator: Aggregator::default(),
+            batch: Batch { from: start, next: start, ..Default::default() },
+            counts: FxHashMap::default(),
+            count_order: Vec::new(),
+            completed: FxHashMap::default(),
+            completed_order: Vec::new(),
+        }
+    }
+
+    pub fn add_text(&mut self, text: &str, next: i64) {
+        let mut segments: Vec<Seg> = Vec::new();
+        let mut crossposts: Vec<String> = Vec::new();
+        let mut obfuscated = 0u64;
+        let mut headers = 0u64;
+        {
+            let group = self.group.clone();
+            let scanner = &mut self.scanner;
+            let priorities = &self.priorities;
+            scan_overview_text(text, |n, subject, from, date, message_id, bytes, xref| {
+                let Some(n) = n else { return };
+                if message_id.is_empty() {
+                    return;
+                }
+                headers += 1;
+                let owner = if xref.is_empty() { group.as_str() } else { scanner.owner(xref, &group, priorities) };
+                if owner != group {
+                    crossposts.push(owner.to_string());
+                    return;
+                }
+                match scanner.segment(n, subject, from, date, message_id, bytes, xref, &group) {
+                    Some(s) => segments.push(s),
+                    None => obfuscated += 1,
+                }
+            });
+        }
+        self.batch.headers += headers;
+        for owner in crossposts {
+            self.count("crosspost", owner, 1, 0);
+        }
+        if obfuscated > 0 {
+            self.count("obfuscated", String::new(), obfuscated, 0);
+        }
+        self.end_chunk(segments, next);
+    }
+
+    fn end_chunk(&mut self, segments: Vec<Seg>, next: i64) {
+        let done = self.aggregator.add(segments);
+        self.files(done);
+        if self.chunk_articles == 0 {
+            self.chunk_articles = next - self.batch.from;
+        }
+        let gone = self.aggregator.evict(self.idle);
+        self.cut_off(gone, false);
+        self.batch.next = next;
+    }
+
+    pub fn finish(&mut self) {
+        let gone = self.aggregator.evict(0);
+        self.cut_off(gone, true);
+        self.batch.next = self.end + 1;
+    }
+
+    pub fn take(&mut self) -> Batch {
+        self.judge_releases();
+        self.scanner.files.clear();
+        let next = self.batch.next;
+        let mut out = std::mem::replace(&mut self.batch, Batch { from: next, next, ..Default::default() });
+        for id in self.count_order.drain(..) {
+            let (articles, files) = self.counts.remove(&id).unwrap();
+            out.counts.push((id.0, id.1, articles, files));
+        }
+        out
+    }
+
+    fn files(&mut self, files: Vec<Vec<Seg>>) {
+        for file in files {
+            let key = release_key_of(&file[0]);
+            match self.completed.get_mut(&key) {
+                Some(list) => list.push(file),
+                None => {
+                    self.completed_order.push(key.clone());
+                    self.completed.insert(key, vec![file]);
+                }
+            }
+        }
+    }
+
+    fn judge_releases(&mut self) {
+        let order = std::mem::take(&mut self.completed_order);
+        let mut by_release = std::mem::take(&mut self.completed);
+        for key in order {
+            let list = by_release.remove(&key).unwrap();
+            let judged: Vec<JudgedFile> = list
+                .iter()
+                .map(|f| JudgedFile { name: &f[0].file.name, total_parts: f[0].file.total_parts, groups: &f[0].file.groups, first_message_id: &f[0].message_id })
+                .collect();
+            match names::judge(&key, &judged) {
+                Verdict::Keep => {
+                    let candidates = candidates_of(&key, &list);
+                    self.batch.releases.push(chunk_of(&key, &list));
+                    self.batch.candidates.extend(candidates);
+                }
+                Verdict::Drop { rule, key: rule_key, sample } => {
+                    let segments: usize = list.iter().map(|f| f.len()).sum();
+                    self.count(rule, rule_key.clone(), segments as u64, list.len() as u64);
+                    if sample {
+                        self.batch.samples.push((chunk_of(&key, &list), rule, rule_key));
+                    }
+                }
+            }
+        }
+    }
+
+    fn cut_off(&mut self, files: Vec<Vec<Seg>>, at_end: bool) {
+        let window = self.idle as i64 * self.chunk_articles.max(1);
+        for list in files {
+            if list.len() == 1 && is_random_file(&list[0].file.name) {
+                let tool = names::upload_tool(&list[0].message_id);
+                self.count("per-article", tool.to_string(), 1, 0);
+                continue;
+            }
+            let min_part = list.iter().map(|s| s.number).min().unwrap();
+            let max_part = list.iter().map(|s| s.number).max().unwrap();
+            let first_article = list.iter().map(|s| s.article).min().unwrap();
+            let cut_at_start = min_part > 1 && first_article < self.start + window;
+            let cut_at_end = at_end && max_part < list[0].file.total_parts;
+            if !cut_at_start && !cut_at_end {
+                self.count("incomplete", String::new(), list.len() as u64, 1);
+                continue;
+            }
+            let f = &list[0].file;
+            let mut fragment = Fragment { file_key: f.file_key.clone(), name: f.name.clone(), total_parts: f.total_parts, posted_at: None, segments: Vec::with_capacity(list.len()) };
+            for s in &list {
+                fragment.segments.push((s.number, s.message_id.clone(), s.bytes, s.article));
+                if let Some(t) = s.posted_at {
+                    if fragment.posted_at.is_none_or(|p| t < p) {
+                        fragment.posted_at = Some(t);
+                    }
+                }
+            }
+            self.batch.fragments.push(fragment);
+        }
+    }
+
+    fn count(&mut self, rule: &'static str, key: String, articles: u64, files: u64) {
+        match self.counts.get_mut(&(rule, key.clone())) {
+            Some(c) => {
+                c.0 += articles;
+                c.1 += files;
+            }
+            None => {
+                self.count_order.push((rule, key.clone()));
+                self.counts.insert((rule, key), (articles, files));
+            }
+        }
+    }
+}
+
+fn release_key_of(s: &Seg) -> String {
+    // A named file always has a release (releaseIdentity isn't null unless weak).
+    s.file.release.key.clone()
+}
+
+fn posted_of(segments: &[Seg]) -> Option<i64> {
+    segments.iter().filter_map(|s| s.posted_at).min()
+}
+
+fn chunk_of(key: &str, files: &[Vec<Seg>]) -> ReleaseChunk {
+    let first = &files[0][0].file;
+    let chunk_files: Vec<ChunkFile> = files
+        .iter()
+        .map(|f| {
+            let m = &f[0].file;
+            ChunkFile { name: &m.name, poster: &m.poster, subject: &m.subject, posted_at: posted_of(f), groups: &m.groups, segments: f.iter().map(|s| (s.number, s.message_id.as_str(), s.bytes)).collect() }
+        })
+        .collect();
+    let mut segments = 0;
+    let mut bytes = 0;
+    let mut first_article = i64::MAX;
+    let mut last_article = 0;
+    let mut posted_at: Option<i64> = None;
+    for f in files {
+        for s in f {
+            segments += 1;
+            bytes += s.bytes;
+            first_article = first_article.min(s.article);
+            last_article = last_article.max(s.article);
+        }
+        if let Some(t) = posted_of(f) {
+            if posted_at.is_none_or(|p| t < p) {
+                posted_at = Some(t);
+            }
+        }
+    }
+    ReleaseChunk {
+        key: key.to_string(),
+        name: first.release.name.clone(),
+        source: first.release.source,
+        file_total: files.iter().find_map(|f| f[0].file.release.file_total_truthy()),
+        poster: first.poster.clone(),
+        groups: first.groups.clone(),
+        posted_at,
+        files: files.len(),
+        segments,
+        bytes,
+        first_article,
+        last_article,
+        readable: chunk_files.iter().any(|f| !is_random_file(f.name)),
+        has_par2: chunk_files.iter().any(|f| names::is_par2(f.name)),
+        payload: encode_chunk(&chunk_files),
+    }
+}
+
+fn candidates_of(key: &str, files: &[Vec<Seg>]) -> Vec<Candidate> {
+    let mut out = Vec::new();
+    let mut tail: Option<(i64, &Vec<Seg>)> = None;
+    let c = |kind, s: &Seg| Candidate { release_key: key.to_string(), kind, message_id: s.message_id.clone(), file: s.file.name.clone() };
+    for f in files {
+        let name = &f[0].file.name;
+        if let Some(volume) = names::seven_zip_volume(name).filter(|&v| v > 1) {
+            if tail.is_none_or(|(v, _)| volume > v) {
+                tail = Some((volume, f));
+            }
+            continue;
+        }
+        if names::is_archive_start(name) {
+            out.push(c("archive", &f[0]));
+        } else if names::is_par2(name) && !names::is_later_volume(name) {
+            out.push(c("par2", &f[0]));
+        }
+    }
+    if let Some((_, f)) = tail {
+        out.push(Candidate { release_key: key.to_string(), kind: "7z-tail", message_id: f.last().unwrap().message_id.clone(), file: f[0].file.name.clone() });
+    }
+    if out.is_empty() && files.len() == 1 && is_random_file(&files[0][0].file.name) {
+        out.push(c("lone", &files[0][0]));
+    }
+    out.truncate(4);
+    out
+}

tools/edge-bench-rs/src/js.rs

@@ -0,0 +1,174 @@
+//! JavaScript semantics the TypeScript worker relies on: `\s` and `trim()`,
+//! UTF-16 lengths, `parseInt`, `Date.parse` (for Usenet dates) and sha1 hex.
+
+use sha1::{Digest, Sha1};
+
+/// JS `\s` / `trim()` whitespace (WhiteSpace and LineTerminator).
+pub fn is_space(c: char) -> bool {
+    matches!(
+        c,
+        '\t' | '\n' | '\u{0B}' | '\u{0C}' | '\r' | ' ' | '\u{A0}' | '\u{1680}' | '\u{2000}'..='\u{200A}' | '\u{2028}' | '\u{2029}' | '\u{202F}' | '\u{205F}' | '\u{3000}' | '\u{FEFF}'
+    )
+}
+
+pub fn trim(s: &str) -> &str {
+    s.trim_matches(is_space)
+}
+
+/// `s.replace(/\s+/g, ' ')`.
+pub fn collapse_spaces(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    let mut in_space = false;
+    for c in s.chars() {
+        if is_space(c) {
+            if !in_space {
+                out.push(' ');
+                in_space = true;
+            }
+        } else {
+            out.push(c);
+            in_space = false;
+        }
+    }
+    out
+}
+
+/// `s.split(/\s+/)`: like JS, a leading or trailing run gives an empty word.
+pub fn split_spaces(s: &str) -> Vec<&str> {
+    let mut out = Vec::new();
+    let mut start = 0;
+    let mut in_space = false;
+    let mut run_start = 0;
+    for (i, c) in s.char_indices() {
+        if is_space(c) {
+            if !in_space {
+                run_start = i;
+                in_space = true;
+            }
+        } else if in_space {
+            out.push(&s[start..run_start]);
+            start = i;
+            in_space = false;
+        }
+    }
+    if in_space {
+        out.push(&s[start..run_start]);
+        out.push("");
+    } else {
+        out.push(&s[start..]);
+    }
+    out
+}
+
+/// A string's `.length` in JavaScript (UTF-16 code units).
+pub fn len16(s: &str) -> usize {
+    if s.is_ascii() {
+        s.len()
+    } else {
+        s.encode_utf16().count()
+    }
+}
+
+/// `Number.parseInt(s, 10)`, None for NaN.
+pub fn parse_int(s: &str) -> Option<i64> {
+    let s = s.trim_start_matches(is_space);
+    let (neg, digits) = match s.as_bytes().first() {
+        Some(b'-') => (true, &s[1..]),
+        Some(b'+') => (false, &s[1..]),
+        _ => (false, s),
+    };
+    let mut n: i64 = 0;
+    let mut any = false;
+    for b in digits.bytes() {
+        if !b.is_ascii_digit() {
+            break;
+        }
+        n = n.wrapping_mul(10).wrapping_add((b - b'0') as i64);
+        any = true;
+    }
+    if any {
+        Some(if neg { -n } else { n })
+    } else {
+        None
+    }
+}
+
+/// `Date.parse` for the Date header (RFC 5322 and the obsolete forms); None for NaN.
+pub fn parse_date(s: &str) -> Option<i64> {
+    let s = trim(s);
+    // "UTC" isn't an RFC 5322 zone (UT and GMT are), but Date.parse takes it (~a quarter of a.b.boneless).
+    let owned;
+    let s = match s.strip_suffix(" UTC") {
+        Some(rest) => {
+            owned = format!("{rest} GMT");
+            owned.as_str()
+        }
+        None => s,
+    };
+    if let Ok(d) = chrono::DateTime::parse_from_rfc2822(s) {
+        return Some(d.timestamp_millis());
+    }
+    // "Mon, 5 Oct 2026 10:00:00 +0000 (UTC)" and other trailing comments.
+    if let Some(i) = s.find(" (") {
+        if let Ok(d) = chrono::DateTime::parse_from_rfc2822(&s[..i]) {
+            return Some(d.timestamp_millis());
+        }
+    }
+    None
+}
+
+/// sha1 of the UTF-8 text, as lowercase hex (node's `hash('sha1', text)`).
+pub fn sha1_hex(text: &str) -> String {
+    let digest = Sha1::digest(text.as_bytes());
+    let mut out = String::with_capacity(40);
+    for b in digest {
+        out.push(char::from_digit((b >> 4) as u32, 16).unwrap());
+        out.push(char::from_digit((b & 15) as u32, 16).unwrap());
+    }
+    out
+}
+
+/// JSON.stringify of a string.
+pub fn json_str(s: &str, out: &mut String) {
+    out.push('"');
+    for c in s.chars() {
+        match c {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\u{08}' => out.push_str("\\b"),
+            '\u{0C}' => out.push_str("\\f"),
+            '\n' => out.push_str("\\n"),
+            '\r' => out.push_str("\\r"),
+            '\t' => out.push_str("\\t"),
+            c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
+            c => out.push(c),
+        }
+    }
+    out.push('"');
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn split_like_js() {
+        assert_eq!(split_spaces("a  b"), vec!["a", "b"]);
+        assert_eq!(split_spaces(" a b "), vec!["", "a", "b", ""]);
+        assert_eq!(split_spaces(""), vec![""]);
+    }
+
+    #[test]
+    fn parse_int_like_js() {
+        assert_eq!(parse_int("123abc"), Some(123));
+        assert_eq!(parse_int("  -5"), Some(-5));
+        assert_eq!(parse_int("x"), None);
+    }
+
+    #[test]
+    fn dates() {
+        assert_eq!(parse_date("Mon, 05 Oct 2026 10:00:00 +0000"), Some(1_791_194_400_000));
+        assert_eq!(parse_date("5 Oct 2026 10:00:00 GMT"), Some(1_791_194_400_000));
+        assert_eq!(parse_date("Mon, 05 Oct 26 10:00:00 UTC"), Some(1_791_194_400_000));
+    }
+}

tools/edge-bench-rs/src/main.rs

@@ -0,0 +1,224 @@
+//! The edge worker's indexing in Rust, on a range captured by `edge:bench
+//! --capture` (REBUILD.md, part 2: TypeScript or Rust). Same work as
+//! edge:bench's replay: inflate each chunk, scan it, aggregate files, cut off
+//! idle ones, and every N chunks judge and encode the releases. `--dump`
+//! writes every output as JSON lines for tools/edge-bench-rs/check.ts.
+//!
+//!   edge-bench-rs <dir> [--batch-chunks 10] [--idle 5] [--dump out.jsonl]
+
+mod codec;
+mod indexer;
+mod js;
+mod names;
+
+use base64::Engine;
+use indexer::{Batch, RangeIndexer};
+use js::json_str;
+use rustc_hash::FxHashMap;
+use std::io::{Read, Write};
+use std::time::Instant;
+
+fn inflate(raw: &[u8]) -> Vec<u8> {
+    let mut out = Vec::with_capacity(raw.len() * 6);
+    if raw.starts_with(&[0x1f, 0x8b]) {
+        flate2::read::MultiGzDecoder::new(raw).read_to_end(&mut out).unwrap();
+    } else {
+        flate2::read::ZlibDecoder::new(raw).read_to_end(&mut out).unwrap();
+    }
+    out
+}
+
+fn json_field(json: &str, name: &str) -> String {
+    let at = json.find(&format!("\"{name}\":")).unwrap() + name.len() + 3;
+    let rest = json[at..].trim_start();
+    if let Some(s) = rest.strip_prefix('"') {
+        s[..s.find('"').unwrap()].to_string()
+    } else {
+        rest[..rest.find([',', '}']).unwrap()].trim().to_string()
+    }
+}
+
+fn peak_rss_mb() -> u64 {
+    let status = std::fs::read_to_string("/proc/self/status").unwrap_or_default();
+    status.lines().find(|l| l.starts_with("VmHWM:")).and_then(|l| l.split_whitespace().nth(1)).and_then(|k| k.parse::<u64>().ok()).unwrap_or(0) / 1024
+}
+
+fn opt_num(n: Option<i64>, out: &mut String) {
+    match n {
+        Some(n) => out.push_str(&n.to_string()),
+        None => out.push_str("null"),
+    }
+}
+
+fn dump_batch(batch: &Batch, out: &mut impl Write) {
+    let b64 = base64::engine::general_purpose::STANDARD;
+    let mut line = String::new();
+    let mut emit = |line: &mut String| {
+        line.push('\n');
+        out.write_all(line.as_bytes()).unwrap();
+        line.clear();
+    };
+    line.push_str(&format!("{{\"t\":\"b\",\"from\":{},\"next\":{},\"headers\":{}}}", batch.from, batch.next, batch.headers));
+    emit(&mut line);
+    let release = |r: &indexer::ReleaseChunk, kind: &str, line: &mut String| {
+        line.push_str(&format!("{{\"t\":\"{kind}\",\"key\":"));
+        json_str(&r.key, line);
+        line.push_str(",\"name\":");
+        json_str(&r.name, line);
+        line.push_str(&format!(",\"source\":\"{}\",\"fileTotal\":", r.source));
+        opt_num(r.file_total, line);
+        line.push_str(",\"poster\":");
+        json_str(&r.poster, line);
+        line.push_str(",\"groups\":[");
+        for (i, g) in r.groups.iter().enumerate() {
+            if i > 0 {
+                line.push(',');
+            }
+            json_str(g, line);
+        }
+        line.push_str("],\"postedAt\":");
+        opt_num(r.posted_at, line);
+        line.push_str(&format!(
+            ",\"files\":{},\"segments\":{},\"bytes\":{},\"firstArticle\":{},\"lastArticle\":{},\"readable\":{},\"hasPar2\":{},\"payload\":\"{}\"",
+            r.files,
+            r.segments,
+            r.bytes,
+            r.first_article,
+            r.last_article,
+            r.readable,
+            r.has_par2,
+            b64.encode(&r.payload)
+        ));
+    };
+    for r in &batch.releases {
+        release(r, "r", &mut line);
+        line.push('}');
+        emit(&mut line);
+    }
+    for (r, rule, key) in &batch.samples {
+        release(r, "s", &mut line);
+        line.push_str(&format!(",\"rule\":\"{rule}\",\"ruleKey\":"));
+        json_str(key, &mut line);
+        line.push('}');
+        emit(&mut line);
+    }
+    for c in &batch.candidates {
+        line.push_str("{\"t\":\"c\",\"releaseKey\":");
+        json_str(&c.release_key, &mut line);
+        line.push_str(&format!(",\"kind\":\"{}\",\"messageId\":", c.kind));
+        json_str(&c.message_id, &mut line);
+        line.push_str(",\"file\":");
+        json_str(&c.file, &mut line);
+        line.push('}');
+        emit(&mut line);
+    }
+    for (rule, key, articles, files) in &batch.counts {
+        line.push_str(&format!("{{\"t\":\"n\",\"rule\":\"{rule}\",\"key\":"));
+        json_str(key, &mut line);
+        line.push_str(&format!(",\"articles\":{articles},\"files\":{files}}}"));
+        emit(&mut line);
+    }
+    for f in &batch.fragments {
+        line.push_str("{\"t\":\"f\",\"fileKey\":");
+        json_str(&f.file_key, &mut line);
+        line.push_str(",\"name\":");
+        json_str(&f.name, &mut line);
+        line.push_str(&format!(",\"totalParts\":{},\"postedAt\":", f.total_parts));
+        opt_num(f.posted_at, &mut line);
+        line.push_str(",\"segments\":[");
+        for (i, (n, id, bytes, article)) in f.segments.iter().enumerate() {
+            if i > 0 {
+                line.push(',');
+            }
+            line.push_str(&format!("[{n},"));
+            json_str(id, &mut line);
+            line.push_str(&format!(",{bytes},{article}]"));
+        }
+        line.push_str("]}");
+        emit(&mut line);
+    }
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let dir = args.get(1).expect("usage: edge-bench-rs <dir> [--batch-chunks N] [--idle N] [--dump file]").clone();
+    let flag = |name: &str| args.iter().position(|a| a == name).and_then(|i| args.get(i + 1)).cloned();
+    let batch_chunks: usize = flag("--batch-chunks").map(|v| v.parse().unwrap()).unwrap_or(10);
+    let idle: u64 = flag("--idle").map(|v| v.parse().unwrap()).unwrap_or(5);
+    let mut dump = flag("--dump").map(|p| std::io::BufWriter::new(std::fs::File::create(p).unwrap()));
+
+    let range = std::fs::read_to_string(format!("{dir}/range.json")).unwrap();
+    let group = json_field(&range, "group");
+    let start: i64 = json_field(&range, "start").parse().unwrap();
+    let end: i64 = json_field(&range, "end").parse().unwrap();
+    let mut files: Vec<String> = std::fs::read_dir(&dir).unwrap().map(|e| e.unwrap().file_name().into_string().unwrap()).filter(|f| f.ends_with(".gz")).collect();
+    files.sort();
+
+    let mut priorities = FxHashMap::default();
+    priorities.insert(group.clone(), 1);
+    let mut indexer = RangeIndexer::new(&group, start, end, priorities, idle);
+
+    let (mut inflate_s, mut index_s) = (0.0, 0.0);
+    let (mut compressed, mut text_bytes) = (0usize, 0usize);
+    let mut out = (0u64, 0usize, 0usize, 0usize, 0usize, 0usize, 0usize, 0usize); // headers, releases, files, segments, payload, candidates, fragments, samples
+    let mut keys = std::collections::HashSet::new();
+    let wall = Instant::now();
+    for (i, file) in files.iter().enumerate() {
+        let raw = std::fs::read(format!("{dir}/{file}")).unwrap();
+        compressed += raw.len();
+        let t = Instant::now();
+        let data = inflate(&raw);
+        inflate_s += t.elapsed().as_secs_f64();
+        text_bytes += data.len();
+        let t = Instant::now();
+        let text = String::from_utf8_lossy(&data);
+        let next: i64 = file.split('-').nth(2).unwrap().trim_end_matches(".gz").parse::<i64>().unwrap() + 1;
+        indexer.add_text(&text, next);
+        let last = i + 1 == files.len();
+        if last {
+            indexer.finish();
+        }
+        if !last && (i + 1) % batch_chunks != 0 {
+            index_s += t.elapsed().as_secs_f64();
+            continue;
+        }
+        let batch = indexer.take();
+        index_s += t.elapsed().as_secs_f64();
+        out.0 += batch.headers;
+        out.1 += batch.releases.len();
+        for r in &batch.releases {
+            keys.insert(r.key.clone());
+            out.2 += r.files;
+            out.3 += r.segments;
+            out.4 += r.payload.len();
+        }
+        out.5 += batch.candidates.len();
+        out.6 += batch.fragments.len();
+        out.7 += batch.samples.len();
+        if let Some(d) = dump.as_mut() {
+            dump_batch(&batch, d);
+        }
+    }
+    let total = inflate_s + index_s;
+    println!("{group} {start}–{end}: {} chunks, {} MB compressed, {} MB text", files.len(), compressed / 1_000_000, text_bytes / 1_000_000);
+    println!(
+        "{} headers in {:.2} s ({:.0}/s on one core; wall {:.2} s)",
+        out.0,
+        total,
+        out.0 as f64 / total,
+        wall.elapsed().as_secs_f64()
+    );
+    println!("  inflate {inflate_s:.2} s, index {index_s:.2} s; peak RSS {} MB", peak_rss_mb());
+    println!(
+        "  kept: {} release chunks ({} releases), {} files, {} segments, payload {:.1} MB ({:.1} B/segment); {} candidates, {} fragments, {} samples",
+        out.1,
+        keys.len(),
+        out.2,
+        out.3,
+        out.4 as f64 / 1e6,
+        out.4 as f64 / out.3.max(1) as f64,
+        out.5,
+        out.6,
+        out.7
+    );
+}

tools/edge-bench-rs/src/names.rs

@@ -0,0 +1,358 @@
+//! lib/release (identity, random), lib/files/volumes and lib/rules/upload_tools.
+//! Regexes run on bytes without Unicode (`(?-u)`): JS regexes without the `u`
+//! flag match ASCII classes, `\d` is [0-9] and `\b` is an ASCII boundary. JS
+//! `\s` (which includes Unicode spaces) is spelled out as SP.
+
+use crate::js::{self, len16, sha1_hex};
+use md5::{Digest, Md5};
+use regex::bytes::Regex;
+use std::sync::LazyLock;
+
+/// JS `\s` as a byte pattern.
+const SP: &str = r"(?:[\t\n\x0B\x0C\r ]|\xC2\xA0|\xE1\x9A\x80|\xE2\x80[\x80-\x8A\xA8\xA9\xAF]|\xE2\x81\x9F|\xE3\x80\x80|\xEF\xBB\xBF)";
+
+fn re(pattern: &str) -> Regex {
+    Regex::new(&format!("(?-u){}", pattern.replace("SP", SP))).unwrap()
+}
+
+/// `s.replace(regex, with)` (first match) or `s.replace(/…/g, with)` (all).
+fn replace(re: &Regex, s: &str, with: &str, all: bool) -> String {
+    let out = if all { re.replace_all(s.as_bytes(), with.as_bytes()) } else { re.replacen(s.as_bytes(), 1, with.as_bytes()) };
+    // The patterns match whole characters (ASCII, or delimited by ASCII), so this stays UTF-8.
+    String::from_utf8(out.into_owned()).unwrap()
+}
+
+fn test(re: &Regex, s: &str) -> bool {
+    re.is_match(s.as_bytes())
+}
+
+static SUFFIXES: LazyLock<Vec<(Regex, &'static str)>> = LazyLock::new(|| {
+    vec![
+        (re(r"(?i)\.vol[0-9]+[+-][0-9]+\.par2$"), ""),
+        (re(r"(?i)\.par2$"), ""),
+        (re(r"(?i)\.part[0-9]+\.rar$"), ""),
+        (re(r"(?i)\.r[0-9]{2,3}$"), ""),
+        (re(r"(?i)\.rar$"), ""),
+        (re(r"(?i)\.7z(\.[0-9]{3})?$"), ""),
+        (re(r"(?i)\.zip(\.[0-9]{3})?$"), ""),
+        // JS: (?<=\.(7z|…))\.\d{3}$ — no lookbehind here, so the extension is matched and put back.
+        (re(r"(?i)(\.(?:7z|zip|rar|tar|mkv|mp4|avi|m4v|ts|m2ts|iso|img|bin|vob))\.[0-9]{3}$"), "$1"),
+        (re(r"(?i)\.(nfo|sfv|nzb|srr|srs|txt|jpg|png|md5|sha1|srt|sub|idx|ass|ssa|m3u|m3u8|cue|log)$"), ""),
+        (re(r"(?i)\.tar$"), ""),
+        (re(r"(?i)\.(zst|gz|xz|bz2)$"), ""),
+        (re(r"(?i)\.(mkv|mp4|avi|m4v|ts|iso|img|bin|flac|mp3|epub|pdf)$"), ""),
+    ]
+});
+
+/// fileStem: per-file suffixes stripped, repeatedly.
+pub fn file_stem(name: &str) -> String {
+    let mut stem = js::trim(name).to_string();
+    let mut changed = true;
+    while changed {
+        changed = false;
+        for (suffix, with) in SUFFIXES.iter() {
+            if !suffix.is_match(stem.as_bytes()) {
+                continue;
+            }
+            let next = replace(suffix, &stem, with, false);
+            if next != stem && !next.is_empty() {
+                stem = next;
+                changed = true;
+            }
+        }
+    }
+    stem
+}
+
+static QUOTED: LazyLock<Regex> = LazyLock::new(|| re(r#""[^"]*""#));
+static COUNTERS: LazyLock<Regex> = LazyLock::new(|| re(r"\[[0-9]+/[0-9]+\]|\([0-9]+/[0-9]+\)"));
+static YENC_END: LazyLock<Regex> = LazyLock::new(|| re(r"(?i)\byEnc\b(SP+[0-9]+)?SP*$"));
+static YENC: LazyLock<Regex> = LazyLock::new(|| re(r"(?i)\byEnc\b"));
+static SEPARATORS: LazyLock<Regex> = LazyLock::new(|| re(r"(?:SP|[-.:|]|\xE2\x80\x93)+"));
+
+pub fn subject_remainder(subject: &str) -> String {
+    let s = replace(&QUOTED, subject, " ", true);
+    let s = replace(&COUNTERS, &s, " ", true);
+    let s = replace(&YENC_END, &s, " ", false);
+    let s = replace(&YENC, &s, " ", true);
+    let s = replace(&SEPARATORS, &s, " ", true);
+    js::trim(&s).to_string()
+}
+
+fn is_random_token(token: &str) -> bool {
+    let t = token.strip_prefix('[').unwrap_or(token);
+    let t = t.strip_suffix(']').unwrap_or(t);
+    if len16(t) < 6 {
+        return false;
+    }
+    let digit = t.bytes().any(|b| b.is_ascii_digit());
+    if digit && t.bytes().all(|b| b.is_ascii_hexdigit()) {
+        return true;
+    }
+    digit && t.bytes().any(|b| b.is_ascii_lowercase()) && t.bytes().any(|b| b.is_ascii_uppercase()) && !t.bytes().any(|b| matches!(b, b'.' | b'_' | b'-'))
+}
+
+pub fn is_post_token(remainder: &str) -> bool {
+    let compact: String = remainder.chars().filter(|&c| !js::is_space(c) && !matches!(c, '[' | ']' | '(' | ')' | '_' | '-')).collect();
+    let n = len16(&compact);
+    (6..=40).contains(&n) && compact.bytes().any(|b| b.is_ascii_digit()) && compact.bytes().all(|b| b.is_ascii_alphanumeric())
+}
+
+static NAME_LIKE: LazyLock<Regex> = LazyLock::new(|| re(r"[A-Za-z]{2,}[._ -]+[A-Za-z0-9]{2,}"));
+
+pub fn names_release(remainder: &str) -> bool {
+    let words: Vec<&str> = js::split_spaces(remainder).into_iter().filter(|w| !w.is_empty() && !is_random_token(w)).collect();
+    test(&NAME_LIKE, &words.join(" "))
+}
+
+#[derive(Debug, Clone)]
+pub struct Release {
+    pub key: String,
+    pub name: String,
+    pub source: &'static str,
+    /// The [i/M] total as parsed (0 is falsy in the TypeScript).
+    pub file_total: Option<i64>,
+}
+
+impl Release {
+    pub fn file_total_truthy(&self) -> Option<i64> {
+        self.file_total.filter(|&n| n != 0)
+    }
+}
+
+static FILE_COUNTER: LazyLock<Regex> = LazyLock::new(|| re(r"\[([0-9]+)/([0-9]+)\]"));
+
+fn hash(parts: &[&str]) -> String {
+    sha1_hex(&parts.join("\n"))
+}
+
+/// releaseIdentity for a named (not weak) file: never null.
+pub fn release_identity(poster: &str, subject: &str, name: &str) -> Release {
+    let file_total = FILE_COUNTER
+        .captures(subject.as_bytes())
+        .and_then(|c| js::parse_int(std::str::from_utf8(&c[2]).unwrap()));
+    let stem = file_stem(name);
+    let remainder = subject_remainder(subject);
+    if names_release(&remainder) {
+        return Release { key: hash(&["subject", poster, &remainder]), name: remainder, source: "subject", file_total };
+    }
+    if let Some(total) = file_total.filter(|&n| n != 0) {
+        if is_post_token(&remainder) {
+            return Release { key: hash(&["post", poster, &remainder, &total.to_string()]), name: remainder, source: "post", file_total };
+        }
+    }
+    Release { key: hash(&["stem", poster, &stem]), name: stem, source: "stem", file_total }
+}
+
+static GENERIC: LazyLock<Regex> = LazyLock::new(|| {
+    re(r"(?i)^(video_ts|audio_ts|bdmv|certificate|hvdvd_ts|samples?|subs?|subtitles?|proof|cover|covers|extras?|featurettes?|(cd|dvd|disc|disk)[ ._-]?[0-9]{1,2})$")
+});
+
+fn is_generic_name(name: &str) -> bool {
+    test(&GENERIC, js::trim(name))
+}
+
+/// looksRandom.
+pub fn looks_random(name: &str) -> bool {
+    // name.replace(/\.[A-Za-z0-9]{1,4}$/, '')
+    let name = match name.rfind('.') {
+        Some(i) if (1..=4).contains(&(name.len() - i - 1)) && name[i + 1..].bytes().all(|b| b.is_ascii_alphanumeric()) => &name[..i],
+        _ => name,
+    };
+    if is_generic_name(name) {
+        return true;
+    }
+    let b = name.as_bytes();
+    let hex = |s: &[u8]| s.iter().all(|c| c.is_ascii_hexdigit());
+    let digits = |s: &[u8]| s.iter().all(|c| c.is_ascii_digit());
+    if b.len() >= 16 && hex(b) {
+        return true;
+    }
+    if let Some(dot) = name.find('.') {
+        let (h, d) = (&b[..dot], &b[dot + 1..]);
+        if h.len() >= 16 && hex(h) && d.len() >= 9 && digits(d) {
+            return true;
+        }
+    }
+    if b.len() == 36 && [8, 13, 18, 23].iter().all(|&i| b[i] == b'-') && b.iter().enumerate().all(|(i, c)| [8, 13, 18, 23].contains(&i) || c.is_ascii_hexdigit()) {
+        return true;
+    }
+    {
+        let core = name.strip_suffix(" n").unwrap_or(name).as_bytes();
+        if core.len() >= 6 && digits(core) {
+            return true;
+        }
+    }
+    let count = |f: fn(&u8) -> bool| b.iter().filter(|c| f(c)).count();
+    let n_digit = count(u8::is_ascii_digit);
+    let n_lower = count(u8::is_ascii_lowercase);
+    let n_upper = count(u8::is_ascii_uppercase);
+    let alnum = b.iter().all(|c| c.is_ascii_alphanumeric());
+    if b.len() >= 12 && b.iter().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit()) && n_digit >= 2 && n_lower >= 4 {
+        return true;
+    }
+    if (8..=15).contains(&b.len()) && alnum && n_digit > 0 && n_lower > 0 && b[1..].iter().filter(|c| c.is_ascii_uppercase()).count() >= 3 {
+        return true;
+    }
+    if !(b.len() >= 16 && alnum) || n_lower == 0 || n_upper == 0 {
+        return false;
+    }
+    n_digit > 0 || n_upper >= 6
+}
+
+pub fn is_random_file(name: &str) -> bool {
+    looks_random(&file_stem(name))
+}
+
+static SEVEN_SPLIT: LazyLock<Regex> = LazyLock::new(|| re(r"(?i)\.7z\.([0-9]{1,4})$"));
+static SEVEN: LazyLock<Regex> = LazyLock::new(|| re(r"(?i)\.7z$"));
+static PART1: LazyLock<Regex> = LazyLock::new(|| re(r"(?i)\.part0*1\.rar$"));
+static RAR: LazyLock<Regex> = LazyLock::new(|| re(r"(?i)\.rar$"));
+static PART: LazyLock<Regex> = LazyLock::new(|| re(r"(?i)\.part([0-9]+)\.rar$"));
+static BIN: LazyLock<Regex> = LazyLock::new(|| re(r"(?i)\.bin$"));
+static OLD_RAR: LazyLock<Regex> = LazyLock::new(|| re(r"(?i)\.r[0-9]{2,3}$"));
+static PAR2_VOL: LazyLock<Regex> = LazyLock::new(|| re(r"(?i)\.vol[0-9]+[+-][0-9]+\.par2$"));
+pub static PAR2: LazyLock<Regex> = LazyLock::new(|| re(r"(?i)\.par2$"));
+
+pub fn is_par2(name: &str) -> bool {
+    test(&PAR2, name)
+}
+
+pub fn seven_zip_volume(name: &str) -> Option<i64> {
+    if let Some(c) = SEVEN_SPLIT.captures(name.as_bytes()) {
+        return js::parse_int(std::str::from_utf8(&c[1]).unwrap());
+    }
+    if test(&SEVEN, name) {
+        Some(0)
+    } else {
+        None
+    }
+}
+
+pub fn is_archive_start(name: &str) -> bool {
+    if test(&BIN, name) {
+        return true;
+    }
+    if matches!(seven_zip_volume(name), Some(0) | Some(1)) {
+        return true;
+    }
+    test(&PART1, name) || (test(&RAR, name) && !test(&PART, name))
+}
+
+pub fn is_later_volume(name: &str) -> bool {
+    if let Some(c) = PART.captures(name.as_bytes()) {
+        return js::parse_int(std::str::from_utf8(&c[1]).unwrap()).unwrap_or(0) > 1;
+    }
+    test(&OLD_RAR, name) || test(&PAR2_VOL, name)
+}
+
+static TOOLS: LazyLock<Vec<(&'static str, Regex)>> = LazyLock::new(|| {
+    vec![
+        ("nyuu", re(r"^(?:[A-Z][a-z]){12}-[0-9]{13}@nyuu$")),
+        ("nyuu-host", re(r"^(?:[A-Z][a-z]){12}-[0-9]{13}@[^\n\r]+$")),
+        ("ngPost", re(r"^[0-9a-f]{32}@ngPost$")),
+        ("yuun", re(r"^[0-9a-f]{32}@[0-9a-f]{32}\.yuun$")),
+        ("hex32", re(r"^[0-9a-f]{32}@[A-Za-z0-9.-]+$")),
+        ("JBinUp", re(r"@JBin(?:Up|Down)\.local$")),
+        ("partNofM", re(r"(?i)^part[0-9]+of[0-9]+\.")),
+        ("ts-dollar", re(r"^[0-9]{13}\$[0-9]+\$[0-9]+@localhost$")),
+        ("random", re(r"^[A-Za-z0-9]{10,40}@[A-Za-z0-9]{3,12}\.[A-Za-z0-9]{2,6}$")),
+    ]
+});
+
+pub fn upload_tool(message_id: &str) -> &'static str {
+    if message_id.is_empty() {
+        return "other";
+    }
+    for (tool, pattern) in TOOLS.iter() {
+        if test(pattern, message_id) {
+            return tool;
+        }
+    }
+    "other"
+}
+
+/// explored: a release in the sampled share of a rule's drops.
+pub fn explored(key: &str, percent: f64) -> bool {
+    if percent <= 0.0 {
+        return false;
+    }
+    let d = Md5::digest(key.as_bytes());
+    let n = u32::from_be_bytes([d[0], d[1], d[2], d[3]]);
+    ((n % 10_000) as f64) < percent * 100.0
+}
+
+static SIDECAR: LazyLock<Regex> = LazyLock::new(|| re(r"(?i)\.(par2|nfo|sfv|txt|jpe?g|png|nzb)$"));
+static EXECUTABLE: LazyLock<Regex> = LazyLock::new(|| re(r"(?i)\.(exe|scr|com|pif|bat|cmd|vbs|lnk)SP*$"));
+
+pub struct JudgedFile<'a> {
+    pub name: &'a str,
+    pub total_parts: u32,
+    pub groups: &'a [String],
+    pub first_message_id: &'a str,
+}
+
+pub enum Verdict {
+    Keep,
+    Drop { rule: &'static str, key: String, sample: bool },
+}
+
+/// RuleSet.judge with DEFAULT_RULES (no dropped signatures).
+pub fn judge(release_key: &str, files: &[JudgedFile]) -> Verdict {
+    const DROPPED_TOOLS: [&str; 5] = ["ngPost", "hex32", "yuun", "JBinUp", "random"];
+    let sample = explored(release_key, 1.0);
+    let content: Vec<&JudgedFile> = files.iter().filter(|f| !test(&SIDECAR, f.name)).collect();
+    if !content.is_empty() && content.iter().all(|f| test(&EXECUTABLE, f.name)) {
+        let c = EXECUTABLE.captures(content[0].name.as_bytes()).unwrap();
+        let key = std::str::from_utf8(&c[1]).unwrap().to_lowercase();
+        return Verdict::Drop { rule: "executable", key, sample };
+    }
+    if files.iter().any(|f| !is_random_file(f.name)) {
+        return Verdict::Keep;
+    }
+    let first = &files[0];
+    let tool = upload_tool(first.first_message_id);
+    let group = first.groups.first().map(String::as_str).unwrap_or("");
+    if DROPPED_TOOLS.contains(&tool) {
+        return Verdict::Drop { rule: "garbage", key: format!("{tool} {group}"), sample };
+    }
+    if files.iter().all(|f| f.total_parts <= 3) {
+        return Verdict::Drop { rule: "per-article", key: tool.to_string(), sample };
+    }
+    Verdict::Keep
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn stems() {
+        assert_eq!(file_stem("x.mkv.vol03+04.par2"), "x");
+        assert_eq!(file_stem("x.part07.rar"), "x");
+        assert_eq!(file_stem("Movie.H.264.mkv.001"), "Movie.H.264");
+        assert_eq!(file_stem("a.7z.002"), "a");
+    }
+
+    #[test]
+    fn remainders() {
+        assert_eq!(subject_remainder(r#"Some.Release [01/45] - "x.rar" yEnc (1/50) 7168"#), "Some Release");
+        assert!(names_release("Some Release"));
+        assert!(!names_release("elys de81bcabef5faf6a"));
+    }
+
+    #[test]
+    fn random_names() {
+        assert!(looks_random("prvjr7hapd0i1ny14pz4"));
+        assert!(looks_random("RmISakytFwXSCEzjVEpaKk"));
+        assert!(!looks_random("Some.Show.S01E01.1080p"));
+        assert!(looks_random("VIDEO_TS"));
+    }
+
+    #[test]
+    fn tools() {
+        assert_eq!(upload_tool("FmFwIaTpGgUiSfYcMwFlMeRo-1790637260478@nyuu"), "nyuu");
+        assert_eq!(upload_tool("b94268bc702040f7b811d5318f727e4f@ngPost"), "ngPost");
+        assert_eq!(upload_tool("x@y"), "other");
+    }
+}