diff --git a/crates/harness/src/bin/text_metrics.rs b/crates/harness/src/bin/text_metrics.rs
new file mode 100644
index 00000000..fd809138
--- /dev/null
+++ b/crates/harness/src/bin/text_metrics.rs
@@ -0,0 +1,493 @@
+//! Measures whether Chromium, Firefox and WebKit agree on text geometry closely enough
+//! to vote on (`specs/text-metrics-oracle.md`). Runs every case in
+//! `harness::text_cases` through the oracle's text probe in each pinned font, votes
+//! every measurement by the rule the geometry vote already uses (`Consensus` at
+//! `dump::TOLERANCE_PX` = 1/60 px), and prints, per font and per category, the share of
+//! measurements that are unanimous, 2-1 and split, plus the largest difference between
+//! any two engines.
+//!
+//! It builds no layout code and scores nothing. A negative result -- the engines do not
+//! agree closely enough -- is the answer, not a failure. The written result is
+//! `docs/text-metrics.md`.
+//!
+//! Usage:
+//!
+//! ```text
+//! cargo run --release -p harness --bin text_metrics
+//! cargo run --release -p harness --bin text_metrics -- --random 60 --seed 0x7e47
+//! ```
+//!
+//! Raw responses are written under `corpus/text-metrics/<font>/<case>.json` (gitignored)
+//! so a rerun on other engine versions can be diffed against this one.
+
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use anyhow::{bail, Context, Result};
+use harness::compare::{self, Consensus};
+use harness::dump::{TextDump, TOLERANCE_PX};
+use harness::oracle::Oracle;
+use harness::text_cases::{self, Case, TextCategory};
+use harness::trace::vote_text;
+
+/// The pinned fonts, in the order the report presents them: the one most likely to
+/// agree first, then the one that says whether agreement survives real advances,
+/// kerning and hinting.
+const FONTS: &[&str] = &["ahem", "lato"];
+
+/// What one font-and-category cell of the report holds.
+#[derive(Debug, Default, Clone)]
+struct Tally {
+    unanimous: usize,
+    majority: usize,
+    split: usize,
+    /// The largest difference between any two engines on a single measurement, in CSS
+    /// pixels, over every measurement in this cell that is measured in pixels. Fragment
+    /// counts are excluded: a line-count difference of one is not a distance, and mixing
+    /// it in would put a hard `1.000000` floor under every cell.
+    max_spread: f64,
+    /// Which measurement that largest difference came from, for naming it in the report.
+    max_spread_at: String,
+    /// Every pixel measurement's spread, kept so the report can say what tolerance the
+    /// engines would agree at, rather than only whether they agree at 1/60 px. A
+    /// measurement is unanimous at tolerance T exactly when its spread is at most T, so
+    /// this list answers the question for every T at once.
+    spreads: Vec<f64>,
+    /// Measurements of how many fragments a box or text node broke into that were not
+    /// unanimous -- a line-breaking difference, counted on its own because it is a
+    /// different kind of disagreement from a sub-pixel one and a worse one: it means the
+    /// engines did not lay out the same lines, so there is nothing to compare within
+    /// them.
+    fragment_count_disputes: usize,
+    /// How often each engine was the named outlier on a 2-1 measurement.
+    outliers: BTreeMap<String, usize>,
+    /// Cases whose probe failed outright in at least one engine.
+    failed_cases: usize,
+}
+
+impl Tally {
+    fn total(&self) -> usize {
+        self.unanimous + self.majority + self.split
+    }
+
+    /// `in_px` is false for a fragment count, which is a number of lines rather than a
+    /// distance and so does not belong in the largest-difference column.
+    fn record(&mut self, consensus: &Consensus, spread: f64, in_px: bool, at: &str) {
+        match consensus {
+            Consensus::Unanimous => self.unanimous += 1,
+            Consensus::Majority { outlier } => {
+                self.majority += 1;
+                *self.outliers.entry(outlier.clone()).or_default() += 1;
+            }
+            Consensus::Split => self.split += 1,
+        }
+        if !in_px {
+            if !matches!(consensus, Consensus::Unanimous) {
+                self.fragment_count_disputes += 1;
+            }
+            return;
+        }
+        self.spreads.push(spread);
+        if spread > self.max_spread {
+            self.max_spread = spread;
+            self.max_spread_at = at.to_string();
+        }
+    }
+
+    fn share(&self, n: usize) -> String {
+        if self.total() == 0 {
+            return "-".to_string();
+        }
+        format!("{:.1}%", 100.0 * n as f64 / self.total() as f64)
+    }
+
+    fn named_outliers(&self) -> String {
+        if self.outliers.is_empty() {
+            return "none".to_string();
+        }
+        self.outliers
+            .iter()
+            .map(|(engine, count)| format!("{engine} x{count}"))
+            .collect::<Vec<_>>()
+            .join(", ")
+    }
+}
+
+struct Args {
+    random: usize,
+    seed: u64,
+}
+
+fn parse_args() -> Result<Args> {
+    let mut args = Args {
+        random: 0,
+        seed: 0x7e47,
+    };
+    let mut argv = std::env::args().skip(1);
+    while let Some(flag) = argv.next() {
+        match flag.as_str() {
+            "--random" => {
+                let value = argv.next().context("--random needs a count")?;
+                args.random = value.parse().context("--random takes a whole number")?;
+            }
+            "--seed" => {
+                let value = argv.next().context("--seed needs a value")?;
+                let parsed = value
+                    .strip_prefix("0x")
+                    .map(|hex| u64::from_str_radix(hex, 16))
+                    .unwrap_or_else(|| value.parse());
+                args.seed = parsed.context("--seed takes a number, decimal or 0x-prefixed")?;
+            }
+            other => bail!("unknown flag: {other}"),
+        }
+    }
+    Ok(args)
+}
+
+/// Stores one case's raw per-engine responses, so a rerun on other engine versions can
+/// be compared against this one rather than re-argued.
+fn store(out_dir: &Path, font: &str, case: &Case, results: &BTreeMap<String, TextDump>) -> Result<()> {
+    let dir = out_dir.join(font);
+    fs::create_dir_all(&dir)?;
+    let path = dir.join(format!("{}.json", case.id));
+    let body = serde_json::json!({
+        "case": case.id,
+        "font": font,
+        "categories": case.categories.iter().map(|c| c.name()).collect::<Vec<_>>(),
+        "html": case.html,
+        "results": results,
+    });
+    fs::write(&path, serde_json::to_string_pretty(&body)?)
+        .with_context(|| format!("writing {}", path.display()))?;
+    Ok(())
+}
+
+/// One voted measurement, flattened so the report can fold it into a per-category and a
+/// per-quantity view without voting twice.
+struct Observation {
+    /// Which quantity this is, as the report labels it. Element and text-fragment
+    /// quantities are kept apart: they answer different questions about the same case.
+    quantity: &'static str,
+    consensus: Consensus,
+    spread: f64,
+    /// False for a fragment count, which is a number of lines rather than a distance.
+    in_px: bool,
+    at: String,
+}
+
+/// The order quantities appear in the per-quantity table: element boxes first, then the
+/// text fragments themselves.
+const QUANTITIES: &[&str] = &[
+    "element x",
+    "element y",
+    "element width",
+    "element height",
+    "element fragment count",
+    "element fragment width",
+    "element fragment height",
+    "text fragment count",
+    "text fragment x",
+    "text fragment y",
+    "text fragment width",
+    "text fragment height",
+];
+
+fn element_quantity(metric: compare::Metric) -> &'static str {
+    match metric {
+        compare::Metric::OffsetX => "element x",
+        compare::Metric::OffsetY => "element y",
+        compare::Metric::Width => "element width",
+        compare::Metric::Height => "element height",
+        compare::Metric::FragmentCount => "element fragment count",
+        compare::Metric::FragmentWidth(_) => "element fragment width",
+        compare::Metric::FragmentHeight(_) => "element fragment height",
+    }
+}
+
+fn text_quantity(metric: harness::trace::TextMetric) -> &'static str {
+    use harness::trace::TextMetric;
+    match metric {
+        TextMetric::FragmentCount => "text fragment count",
+        TextMetric::FragmentX(_) => "text fragment x",
+        TextMetric::FragmentY(_) => "text fragment y",
+        TextMetric::FragmentWidth(_) => "text fragment width",
+        TextMetric::FragmentHeight(_) => "text fragment height",
+    }
+}
+
+/// Votes one case in one font, flattening every measurement into an [`Observation`] the
+/// caller folds into both views of the report.
+fn measure(case: &Case, results: &BTreeMap<String, TextDump>) -> Result<Vec<Observation>> {
+    let mut observations = Vec::new();
+
+    // Element bounding boxes go through the geometry vote unchanged: the element half of
+    // a text-probe response is an ordinary dump, so there is no second implementation of
+    // the same rule for it.
+    let geometry: BTreeMap<String, harness::dump::Dump> = results
+        .iter()
+        .map(|(name, dump)| (name.clone(), dump.geometry()))
+        .collect();
+    match compare::vote(&geometry) {
+        Ok(report) => {
+            for m in &report.measurements {
+                let values: Vec<f64> = m.values.values().copied().collect();
+                observations.push(Observation {
+                    quantity: element_quantity(m.metric),
+                    consensus: m.consensus.clone(),
+                    spread: spread_of(&values),
+                    in_px: !matches!(m.metric, compare::Metric::FragmentCount),
+                    at: format!("{} element {} {:?}", case.id, m.node_index, m.metric),
+                });
+            }
+        }
+        Err(e) => bail!("{}: element vote unavailable: {e:?}", case.id),
+    }
+
+    // Text-node line fragments. A text node that produced no line box in any engine --
+    // the contents of `<style>`, among others -- contributes its unanimous fragment
+    // count and nothing else, so it is dropped here rather than counted as agreement
+    // about geometry that does not exist.
+    match vote_text(results) {
+        Ok(report) => {
+            for m in &report.measurements {
+                let rendered = results
+                    .values()
+                    .any(|d| !d.texts[m.text_index].rects.is_empty());
+                if !rendered {
+                    continue;
+                }
+                observations.push(Observation {
+                    quantity: text_quantity(m.metric),
+                    consensus: m.consensus.clone(),
+                    spread: m.spread(),
+                    in_px: !matches!(m.metric, harness::trace::TextMetric::FragmentCount),
+                    at: format!("{} text {} {:?}", case.id, m.text_index, m.metric),
+                });
+            }
+        }
+        Err(e) => bail!("{}: text vote unavailable: {e:?}", case.id),
+    }
+
+    Ok(observations)
+}
+
+fn spread_of(values: &[f64]) -> f64 {
+    let min = values.iter().copied().fold(f64::INFINITY, f64::min);
+    let max = values.iter().copied().fold(f64::NEG_INFINITY, f64::max);
+    if min.is_finite() && max.is_finite() {
+        max - min
+    } else {
+        0.0
+    }
+}
+
+fn print_table(
+    font: &str,
+    per_category: &BTreeMap<TextCategory, Tally>,
+    per_quantity: &BTreeMap<&'static str, Tally>,
+    overall: &Tally,
+) {
+    let header = |first: &str| {
+        println!(
+            "| {:<22} | {:>7} | {:>10} | {:>7} | {:>7} | {:>12} | {:>11} |",
+            first, "voted", "unanimous", "2-1", "split", "max delta px", "line splits"
+        );
+        println!(
+            "| {:-<22} | {:->7} | {:->10} | {:->7} | {:->7} | {:->12} | {:->11} |",
+            "", "", "", "", "", "", ""
+        );
+    };
+    let row = |label: &str, tally: &Tally| {
+        println!(
+            "| {:<22} | {:>7} | {:>10} | {:>7} | {:>7} | {:>12.6} | {:>11} |",
+            label,
+            tally.total(),
+            tally.share(tally.unanimous),
+            tally.share(tally.majority),
+            tally.share(tally.split),
+            tally.max_spread,
+            tally.fragment_count_disputes,
+        );
+    };
+
+    println!("\n== {font} ==");
+    header("category");
+    for category in TextCategory::ALL {
+        let Some(tally) = per_category.get(category) else {
+            continue;
+        };
+        row(category.name(), tally);
+    }
+    row("all", overall);
+
+    // The same measurements grouped by what was measured rather than by which case
+    // measured it. This is what says whether a disagreement is spread across text
+    // geometry or confined to one quantity, which decides what can still be scored.
+    println!();
+    header("quantity");
+    for quantity in QUANTITIES {
+        let Some(tally) = per_quantity.get(quantity) else {
+            continue;
+        };
+        row(quantity, tally);
+        if tally.total() != tally.unanimous {
+            println!("| {:<22} | outlier: {:<76} |", "", tally.named_outliers());
+        }
+    }
+
+    println!("outlier: {}", overall.named_outliers());
+    if !overall.max_spread_at.is_empty() {
+        println!("largest difference at: {}", overall.max_spread_at);
+    }
+    // The verdict the result doc has to state, in the terms the vote uses.
+    let verdict = if overall.split == 0 && overall.majority == 0 {
+        format!("every measurement unanimous at {TOLERANCE_PX:.6} px")
+    } else if overall.split == 0 {
+        format!(
+            "no measurement split; {} of {} carry a named outlier, largest difference {:.6} px",
+            overall.majority,
+            overall.total(),
+            overall.max_spread
+        )
+    } else {
+        format!(
+            "{} of {} measurements split with no reference value, largest difference {:.6} px",
+            overall.split,
+            overall.total(),
+            overall.max_spread
+        )
+    };
+    println!("verdict input: {verdict}");
+    println!(
+        "line-breaking disagreements: {} (a differing fragment count, not a distance)",
+        overall.fragment_count_disputes
+    );
+
+    // What tolerance the engines would agree at, which is the other half of the verdict:
+    // a measurement is unanimous at tolerance T exactly when its spread is at most T.
+    println!("\nshare of the {} pixel measurements unanimous at a given tolerance:", overall.spreads.len());
+    for tolerance in [TOLERANCE_PX, 0.125, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0] {
+        let within = overall
+            .spreads
+            .iter()
+            .filter(|&&s| s <= tolerance)
+            .count();
+        let label = if (tolerance - TOLERANCE_PX).abs() < f64::EPSILON {
+            "1/60 (the vote)".to_string()
+        } else {
+            format!("{tolerance}")
+        };
+        println!(
+            "  {:<16} {:>6.2}%  ({} of {})",
+            label,
+            100.0 * within as f64 / overall.spreads.len().max(1) as f64,
+            within,
+            overall.spreads.len(),
+        );
+    }
+}
+
+fn main() -> Result<()> {
+    let args = parse_args()?;
+    let repo_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .and_then(|p| p.parent())
+        .expect("crate sits two levels below the repository root")
+        .to_path_buf();
+    let out_dir = repo_root.join("corpus/text-metrics");
+
+    let mut cases = text_cases::enumerated();
+    if args.random > 0 {
+        cases.extend(text_cases::random(args.seed, args.random));
+    }
+
+    let mut oracle = Oracle::start(&repo_root, None, None)?;
+    let engines = oracle.engines.clone();
+    println!("engines: {}", engines.join(", "));
+    for name in &engines {
+        let version = oracle
+            .versions
+            .get(name)
+            .map(String::as_str)
+            .unwrap_or("unknown");
+        println!("  {name}: {version}");
+    }
+    if engines.len() < 3 {
+        bail!("the geometry vote needs three engines, got {engines:?}");
+    }
+    println!("cases: {} ({} fonts)", cases.len(), FONTS.len());
+
+    for font in FONTS {
+        let mut per_category: BTreeMap<TextCategory, Tally> = BTreeMap::new();
+        let mut per_quantity: BTreeMap<&'static str, Tally> = BTreeMap::new();
+        let mut overall = Tally::default();
+        let mut font_sha = String::new();
+
+        for case in &cases {
+            let (results, errors) = oracle.text_probe(&case.html, font)?;
+            for (engine, message) in &errors {
+                eprintln!("{font}/{}: {engine} failed: {message}", case.id);
+            }
+            let results: BTreeMap<String, TextDump> = results.into_iter().collect();
+            if results.len() < engines.len() {
+                // A probe that did not answer in every engine cannot be voted, and the
+                // most likely reason is the one this probe exists to catch: the pinned
+                // font did not load, so the page would have been measured against a
+                // substituted system font.
+                overall.failed_cases += 1;
+                for category in &case.categories {
+                    per_category.entry(*category).or_default().failed_cases += 1;
+                }
+                continue;
+            }
+            if font_sha.is_empty() {
+                font_sha = results
+                    .values()
+                    .next()
+                    .map(|d| d.font_sha256.clone())
+                    .unwrap_or_default();
+            }
+
+            store(&out_dir, font, case, &results)?;
+            for observation in measure(case, &results)? {
+                for category in &case.categories {
+                    per_category.entry(*category).or_default().record(
+                        &observation.consensus,
+                        observation.spread,
+                        observation.in_px,
+                        &observation.at,
+                    );
+                }
+                per_quantity
+                    .entry(observation.quantity)
+                    .or_default()
+                    .record(
+                        &observation.consensus,
+                        observation.spread,
+                        observation.in_px,
+                        &observation.at,
+                    );
+                overall.record(
+                    &observation.consensus,
+                    observation.spread,
+                    observation.in_px,
+                    &observation.at,
+                );
+            }
+        }
+
+        println!("\nfont {font}: sha256 {font_sha}");
+        if overall.failed_cases > 0 {
+            println!(
+                "{} case(s) did not answer in every engine and were not voted",
+                overall.failed_cases
+            );
+        }
+        print_table(font, &per_category, &per_quantity, &overall);
+    }
+
+    println!("\nraw responses: {}", out_dir.display());
+    oracle.shutdown()?;
+    Ok(())
+}
diff --git a/crates/harness/src/dump.rs b/crates/harness/src/dump.rs
index 84fa0324..980f130b 100644
--- a/crates/harness/src/dump.rs
+++ b/crates/harness/src/dump.rs
@@ -63,6 +63,23 @@ pub struct StackingPoint {
     pub ids: Vec<String>,
 }
 
+/// One text node's geometry, as one engine reported it (`docs/dump-format.md` ->
+/// "Text probe"). `rects` is `Range.getClientRects()` over the node's contents: one rect
+/// per line fragment, in line order, and empty for a text node that generates no line
+/// box at all (the contents of `<style>`, among others).
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct TextRun {
+    /// Index into `TextDump::nodes` of the element this text node is a child of.
+    pub parent: usize,
+    /// The node's data, truncated by the oracle. Only the rects are measured; the text
+    /// is carried so a stored response can be read, and a text probe's document holds
+    /// the pinned font's base64 `data:` URL as one enormous text node.
+    pub text: String,
+    #[serde(default)]
+    pub truncated: bool,
+    pub rects: Vec<Rect>,
+}
+
 /// One node's scrollbar probe: the client (padding box) and scroll (content extent)
 /// dimensions CSSOM-View reports for it. The pair differs on an axis exactly when the
 /// element's content spills past its padding box on that axis -- whatever the element's
@@ -163,6 +180,67 @@ pub struct Request {
     pub op: Option<String>,
 }
 
+/// One request line asking the oracle to render `html` with the pinned font `font` and
+/// report both the element dump and every text node's line-fragment rects, per
+/// `docs/dump-format.md` -> "Text probe".
+#[derive(Debug, Clone, Serialize)]
+pub struct TextRequest<'a> {
+    pub id: String,
+    pub op: &'static str,
+    pub html: &'a str,
+    /// Which pinned font to measure in: `ahem` or `lato`. The oracle reads its bytes
+    /// from the WPT checkout `oracle/suites/suites.json` pins.
+    pub font: &'a str,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub engines: Option<&'a [String]>,
+}
+
+/// One engine's answer to a `textProbe` request: the ordinary element dump plus the text
+/// nodes, and the exact font bytes the numbers are tied to.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct TextDump {
+    pub engine: String,
+    pub engine_version: String,
+    /// The requested font key, echoed.
+    pub font: String,
+    /// sha256 of the font file the oracle embedded, so a figure is tied to exact bytes
+    /// rather than to a file name.
+    pub font_sha256: String,
+    /// The one family name every case declares, whichever font key was requested.
+    pub font_family: String,
+    pub viewport: Viewport,
+    pub overflowed: bool,
+    /// Every element in document order, exactly what an ordinary dump carries.
+    pub nodes: Vec<Node>,
+    /// Every text node in document order.
+    pub texts: Vec<TextRun>,
+}
+
+impl TextDump {
+    /// The element half of this response as an ordinary [`Dump`], so element bounding
+    /// boxes go through `crate::compare::vote` unchanged rather than through a second
+    /// implementation of the same vote.
+    pub fn geometry(&self) -> Dump {
+        Dump {
+            engine: self.engine.clone(),
+            engine_version: self.engine_version.clone(),
+            viewport: self.viewport,
+            overflowed: self.overflowed,
+            nodes: self.nodes.clone(),
+        }
+    }
+}
+
+/// One response line answering a `textProbe` request.
+#[derive(Debug, Clone, Deserialize)]
+pub struct TextResponse {
+    pub id: String,
+    #[serde(default)]
+    pub results: std::collections::BTreeMap<String, TextDump>,
+    #[serde(default)]
+    pub errors: std::collections::BTreeMap<String, String>,
+}
+
 /// One response line on the oracle's stdout.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Response {
@@ -179,3 +257,74 @@ pub struct Response {
     #[serde(default)]
     pub versions: Option<std::collections::BTreeMap<String, String>>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A `textProbe` response line as the oracle actually emitted one, trimmed to two
+    /// elements and two text nodes. Recorded rather than hand-shaped so the Rust types
+    /// are checked against the wire, not against an idea of it.
+    const RECORDED_TEXT_RESPONSE: &str = r#"{
+      "id": "t1",
+      "results": {
+        "chromium": {
+          "engine": "chromium",
+          "engine_version": "153.0.8010.12",
+          "font": "ahem",
+          "font_sha256": "b719ecb31c5b21fc573c03f6421c74ac63c271a5a3ff841e34f9705fb94b8448",
+          "font_family": "probe",
+          "viewport": {"width": 800, "height": 600},
+          "overflowed": false,
+          "nodes": [
+            {"index": 0, "parent": -1, "tag": "HTML", "depth": 0,
+             "bounding": {"x": 0, "y": 0, "w": 800, "h": 16},
+             "rects": [{"x": 0, "y": 0, "w": 800, "h": 16}],
+             "scroll": {"client_width": 800, "client_height": 600, "scroll_width": 800, "scroll_height": 600},
+             "style": {"display": "block"}},
+            {"index": 1, "parent": 0, "tag": "DIV", "depth": 1,
+             "bounding": {"x": 0, "y": 0, "w": 200, "h": 16},
+             "rects": [{"x": 0, "y": 0, "w": 200, "h": 16}],
+             "scroll": {"client_width": 200, "client_height": 16, "scroll_width": 200, "scroll_height": 16},
+             "style": {"display": "block"}}
+          ],
+          "texts": [
+            {"parent": 0, "text": "@font-face{font-family:\"probe\";src:url(data:font/ttf;base64,AAEA", "truncated": true, "rects": []},
+            {"parent": 1, "text": "wrap wrap", "truncated": false, "rects": [{"x": 0, "y": 0, "w": 144, "h": 16}]}
+          ]
+        }
+      }
+    }"#;
+
+    #[test]
+    fn a_recorded_text_probe_response_parses() {
+        let response: TextResponse = serde_json::from_str(RECORDED_TEXT_RESPONSE).unwrap();
+        assert_eq!(response.id, "t1");
+        assert!(response.errors.is_empty());
+
+        let dump = &response.results["chromium"];
+        assert_eq!(dump.font, "ahem");
+        assert_eq!(dump.font_family, "probe");
+        assert_eq!(dump.font_sha256.len(), 64);
+        assert_eq!(dump.nodes.len(), 2);
+        assert_eq!(dump.texts.len(), 2);
+
+        // A text node inside <style> generates no line box, so it carries no rects; the
+        // rendered one carries exactly one, since it fits on one line.
+        assert!(dump.texts[0].truncated);
+        assert!(dump.texts[0].rects.is_empty());
+        assert_eq!(dump.texts[1].parent, 1);
+        assert_eq!(dump.texts[1].rects.len(), 1);
+        assert_eq!(dump.texts[1].rects[0].w, 144.0);
+    }
+
+    #[test]
+    fn the_element_half_of_a_text_probe_is_an_ordinary_dump() {
+        let response: TextResponse = serde_json::from_str(RECORDED_TEXT_RESPONSE).unwrap();
+        let geometry = response.results["chromium"].geometry();
+        assert_eq!(geometry.engine, "chromium");
+        assert_eq!(geometry.nodes.len(), 2);
+        assert_eq!(geometry.viewport.width, 800);
+        assert_eq!(geometry.parent_of(&geometry.nodes[1]).unwrap().tag, "HTML");
+    }
+}
diff --git a/crates/harness/src/lib.rs b/crates/harness/src/lib.rs
index f105ad3e..ec9605b1 100644
--- a/crates/harness/src/lib.rs
+++ b/crates/harness/src/lib.rs
@@ -14,6 +14,7 @@ pub mod overflow_cases;
 pub mod reflect;
 pub mod relpos_cases;
 pub mod stacking_cases;
+pub mod text_cases;
 pub mod trace;
 
 #[cfg(feature = "smt")]
diff --git a/crates/harness/src/oracle.rs b/crates/harness/src/oracle.rs
index 8d6612f0..27f6cc61 100644
--- a/crates/harness/src/oracle.rs
+++ b/crates/harness/src/oracle.rs
@@ -10,7 +10,7 @@ use std::process::{Child, ChildStdin, ChildStdout, Command, Stdio};
 use anyhow::{anyhow, bail, Context, Result};
 use serde::{Deserialize, Serialize};
 
-use crate::dump::{Dump, Request, Response};
+use crate::dump::{Dump, Request, Response, TextDump, TextRequest, TextResponse};
 use crate::reflect::{Probe, ReflectDump, ReflectRequest, ReflectResponse};
 use crate::trace::{
     EngineStacking, EngineTrace, StackingRequest, StackingResponse, TraceRequest, TraceResponse,
@@ -199,6 +199,32 @@ impl Oracle {
         ))
     }
 
+    /// Renders `html` in the pinned font `font` and reports, per engine, the ordinary
+    /// element dump plus every text node's line-fragment rects (`docs/dump-format.md` ->
+    /// "Text probe"). Mirrors `stacking_probe`: a per-engine failure is reported
+    /// alongside the results that did succeed. An engine whose page fell back to a
+    /// system font appears here as an error rather than as a measurement, since a
+    /// substituted font would make the agreement figure meaningless.
+    pub fn text_probe(
+        &mut self,
+        html: &str,
+        font: &str,
+    ) -> Result<(HashMap<String, TextDump>, HashMap<String, String>)> {
+        let id = self.take_id();
+        self.send(&TextRequest {
+            id: id.clone(),
+            op: "textProbe",
+            html,
+            font,
+            engines: None,
+        })?;
+        let response: TextResponse = self.recv(&id)?;
+        Ok((
+            response.results.into_iter().collect(),
+            response.errors.into_iter().collect(),
+        ))
+    }
+
     pub fn shutdown(mut self) -> Result<()> {
         let id = self.take_id();
         let _ = self.send(&Request {
diff --git a/crates/harness/src/text_cases.rs b/crates/harness/src/text_cases.rs
new file mode 100644
index 00000000..37fbb4e4
--- /dev/null
+++ b/crates/harness/src/text_cases.rs
@@ -0,0 +1,491 @@
+//! Stratified generation of text-geometry cases for the text-metrics measurement
+//! (`specs/text-metrics-oracle.md`), `crate::stacking_cases`'s counterpart for the text
+//! probe. It answers one question and builds no layout: do Chromium, Firefox and WebKit
+//! place glyphs closely enough for the geometry vote to run on a text-bearing document?
+//!
+//! Unlike every other corpus in this crate, these documents contain text, so this file
+//! writes its own markup rather than going through `crate::cases::Elem`, which renders
+//! only empty `<div>`s. It does reuse `crate::cases::RESET`, so the same UA-stylesheet
+//! differences are excluded here as everywhere else, and `crate::cases::Source`, so a
+//! case is drawn from the same fixed-or-seeded-random pools. **Do not add to
+//! `crate::cases`'s own `RECIPES`**: this corpus is measured, never scored.
+//!
+//! Every case names one font family, `probe`, with no fallback list. The bytes behind
+//! that name are chosen per request by the oracle's `textProbe` operation
+//! (`docs/dump-format.md` -> "Text probe"), which embeds a font from the pinned WPT
+//! checkout as a `data:` URL and fails the request if the face did not load. That is why
+//! a category's markup is identical in both fonts: the only thing that varies between a
+//! case's Ahem run and its Lato run is the font file, so a difference in the numbers is
+//! a difference the font caused.
+//!
+//! In scope, matching the spec: Latin text in one writing mode, at integer and
+//! fractional font sizes, wrapped and unwrapped, with explicit line heights, preserved
+//! white space, an inline `<span>`, letter spacing, a kerning pair and centred
+//! alignment. Out: shaping beyond Latin, bidi, vertical writing modes, system fonts and
+//! text painting.
+
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+
+use crate::cases::{self, Source};
+
+/// The one family name every case declares. The oracle binds it to a pinned font file
+/// per request; nothing falls back to a system font, and a face that fails to load fails
+/// the request instead of being measured.
+pub const FONT_FAMILY: &str = "probe";
+
+/// A category of text geometry this corpus exercises, drawn from
+/// `specs/text-metrics-oracle.md`'s own list.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum TextCategory {
+    /// One word at an integer font size, on one line, in a container wide enough to hold
+    /// it. The simplest thing a text-bearing vote could ask for: if the engines split
+    /// here, they split everywhere.
+    IntegerFontSize,
+    /// One word at a fractional font size (`13.5px`, `17.03125px`). A font size that is
+    /// not a whole pixel forces each engine to round advances on its own grid, which is
+    /// exactly where `docs/firefox-app-units.md` found engines drifting apart for boxes.
+    FractionalFontSize,
+    /// Several words in a container narrow enough to wrap them, so the text node reports
+    /// one rect per line fragment. Line breaking decides how many, and the engines have
+    /// to agree on that before any per-fragment number means anything.
+    WrappingFixedWidth,
+    /// Explicit `line-height` in pixels, so fragment height and the vertical step
+    /// between fragments come from a stated length rather than from font metrics.
+    LineHeightPx,
+    /// Explicit `line-height` as a unitless number, so the used value is computed from
+    /// the font size and each engine's own rounding of that product shows up.
+    LineHeightNumber,
+    /// `white-space: pre` with runs of repeated spaces, which are collapsed away in
+    /// every other category. A space's advance is a font metric like any other, and
+    /// preserving them multiplies whatever error one space carries.
+    WhiteSpacePre,
+    /// A `<span>` inside a line, measured through its own element rects as well as the
+    /// text nodes either side of it. An inline box's geometry is where text and box
+    /// layout meet.
+    SpanInsideLine,
+    /// `letter-spacing` in pixels, which adds a fixed amount to every glyph advance and
+    /// so accumulates any per-glyph rounding difference along the line.
+    LetterSpacing,
+    /// A kerning pair (`AV`, `To`) repeated along a line. Ahem has no kerning at all, so
+    /// this category is the sharpest difference between the two fonts: in the
+    /// proportional font it asks whether the engines apply the same pair adjustments.
+    KerningPair,
+    /// `text-align: center`, so the line's start offset is half of the leftover space --
+    /// a division that turns any width disagreement into a position disagreement, at
+    /// half the size.
+    TextAlignCenter,
+}
+
+impl TextCategory {
+    /// Every category the generators are expected to cover.
+    pub const ALL: &'static [TextCategory] = &[
+        TextCategory::IntegerFontSize,
+        TextCategory::FractionalFontSize,
+        TextCategory::WrappingFixedWidth,
+        TextCategory::LineHeightPx,
+        TextCategory::LineHeightNumber,
+        TextCategory::WhiteSpacePre,
+        TextCategory::SpanInsideLine,
+        TextCategory::LetterSpacing,
+        TextCategory::KerningPair,
+        TextCategory::TextAlignCenter,
+    ];
+
+    /// A short stable name, used as a column label in the measurement's tables and in
+    /// the file name a raw response is stored under.
+    pub fn name(self) -> &'static str {
+        match self {
+            TextCategory::IntegerFontSize => "integer-font-size",
+            TextCategory::FractionalFontSize => "fractional-font-size",
+            TextCategory::WrappingFixedWidth => "wrapping-fixed-width",
+            TextCategory::LineHeightPx => "line-height-px",
+            TextCategory::LineHeightNumber => "line-height-number",
+            TextCategory::WhiteSpacePre => "white-space-pre",
+            TextCategory::SpanInsideLine => "span-inside-line",
+            TextCategory::LetterSpacing => "letter-spacing",
+            TextCategory::KerningPair => "kerning-pair",
+            TextCategory::TextAlignCenter => "text-align-center",
+        }
+    }
+}
+
+/// One generated case, `crate::stacking_cases::Case`'s counterpart for text.
+#[derive(Debug, Clone)]
+pub struct Case {
+    pub id: String,
+    pub html: String,
+    pub seed: u64,
+    pub categories: Vec<TextCategory>,
+    pub element_count: usize,
+}
+
+/// Assembles one document: the shared reset, the case's own rules, and its body. Mirrors
+/// `crate::cases::document`'s output shape, including the `<head>` the oracle's text
+/// probe inserts its `@font-face` rule into, but takes literal markup because a text
+/// case's body is not a tree of empty `<div>`s.
+fn document(css: &str, body: &str) -> String {
+    let reset = cases::RESET;
+    format!(
+        "<!doctype html>\n<html>\n<head>\n<meta charset=\"utf-8\">\n<style>\n{reset}{css}</style>\n</head>\n<body>\n{body}\n</body>\n</html>\n"
+    )
+}
+
+fn make_case(name: &str, seed: u64, categories: &[TextCategory], css: &str, body: &str) -> Case {
+    let html = document(css, body);
+    // Counted from the markup rather than carried by hand, so the metadata cannot drift
+    // from the document. `<html>`, `<head>`, `<meta>`, `<style>` and `<body>` are not
+    // counted; only the boxes the case itself creates are.
+    let element_count = body.matches("<div").count() + body.matches("<span").count();
+    Case {
+        id: name.to_string(),
+        html,
+        seed,
+        categories: categories.to_vec(),
+        element_count,
+    }
+}
+
+/// The rule every case's outer box opens with: one pinned family, no fallback, and a
+/// stated width so line breaking is decided by the case and not by the viewport.
+fn page_rule(width: f64, font_size: String, extra: &str) -> String {
+    format!(
+        ".page {{ width: {}; font-family: \"{FONT_FAMILY}\"; font-size: {font_size}; {extra}}}\n",
+        cases::px(width)
+    )
+}
+
+type Recipe = for<'a> fn(&mut Source<'a>) -> (String, String, Vec<TextCategory>, &'static str);
+
+fn recipe_integer_font_size(src: &mut Source) -> (String, String, Vec<TextCategory>, &'static str) {
+    // One word, one line, a container far wider than the word at any of the drawn sizes,
+    // so nothing wraps and the only question is how wide the engines make the glyphs.
+    let size = src.px(&[16.0, 24.0, 32.0]);
+    let css = page_rule(600.0, cases::px(size), "line-height: 1; ");
+    (
+        css,
+        "<div class=\"page\">Hamburgefonstiv</div>".to_string(),
+        vec![TextCategory::IntegerFontSize],
+        "text-integer-font-size",
+    )
+}
+
+fn recipe_fractional_font_size(
+    src: &mut Source,
+) -> (String, String, Vec<TextCategory>, &'static str) {
+    // 13.5px is a half pixel; 17.03125px is 17 + 1/32, which lands between Firefox's
+    // 1/60 grid and the 1/64 grid Chromium and WebKit use, so neither can represent it
+    // exactly and each rounds it its own way.
+    let size = src.px(&[13.5, 17.03125, 21.25]);
+    let css = page_rule(600.0, cases::px(size), "line-height: 1; ");
+    (
+        css,
+        "<div class=\"page\">Hamburgefonstiv</div>".to_string(),
+        vec![TextCategory::FractionalFontSize],
+        "text-fractional-font-size",
+    )
+}
+
+fn recipe_wrapping_fixed_width(
+    src: &mut Source,
+) -> (String, String, Vec<TextCategory>, &'static str) {
+    // Every drawn width is narrow enough to force at least two lines in either font at
+    // 16px, so the text node always reports more than one fragment.
+    let width = src.px(&[180.0, 220.0, 260.0]);
+    let css = page_rule(width, cases::px(16.0), "line-height: 1; ");
+    (
+        css,
+        "<div class=\"page\">alpha bravo charlie delta echo foxtrot golf hotel</div>".to_string(),
+        vec![TextCategory::WrappingFixedWidth],
+        "text-wrapping-fixed-width",
+    )
+}
+
+fn recipe_line_height_px(src: &mut Source) -> (String, String, Vec<TextCategory>, &'static str) {
+    // A stated line height, including a fractional one, over wrapped text, so the
+    // vertical step between fragments is the quantity under test.
+    let leading = src.px(&[28.0, 21.5, 33.75]);
+    let css = page_rule(
+        200.0,
+        cases::px(16.0),
+        &format!("line-height: {}; ", cases::px(leading)),
+    );
+    (
+        css,
+        "<div class=\"page\">alpha bravo charlie delta echo</div>".to_string(),
+        vec![TextCategory::LineHeightPx],
+        "text-line-height-px",
+    )
+}
+
+fn recipe_line_height_number(src: &mut Source) -> (String, String, Vec<TextCategory>, &'static str) {
+    // A unitless line height: the used value is the number times the font size, so 1.375
+    // at 16px is 22px exactly while 1.7 at 16px is 27.2px, which no engine's grid holds.
+    let factor = src.px(&[1.375, 1.7, 2.0]);
+    let css = page_rule(200.0, cases::px(16.0), &format!("line-height: {factor}; "));
+    (
+        css,
+        "<div class=\"page\">alpha bravo charlie delta echo</div>".to_string(),
+        vec![TextCategory::LineHeightNumber],
+        "text-line-height-number",
+    )
+}
+
+fn recipe_white_space_pre(src: &mut Source) -> (String, String, Vec<TextCategory>, &'static str) {
+    // Runs of two, five and nine spaces, preserved rather than collapsed. The drawn size
+    // varies how much a single space's advance is worth.
+    let size = src.px(&[16.0, 20.0, 28.0]);
+    let css = page_rule(
+        700.0,
+        cases::px(size),
+        "line-height: 1; white-space: pre; ",
+    );
+    (
+        css,
+        "<div class=\"page\">a  b     c         d</div>".to_string(),
+        vec![TextCategory::WhiteSpacePre],
+        "text-white-space-pre",
+    )
+}
+
+fn recipe_span_inside_line(src: &mut Source) -> (String, String, Vec<TextCategory>, &'static str) {
+    // Three text nodes on one line -- before the span, inside it, after it -- so the
+    // span's own element rects are measured alongside them and a disagreement can be
+    // pinned to the inline box or to the text.
+    let size = src.px(&[16.0, 18.0, 24.0]);
+    let mut css = page_rule(700.0, cases::px(size), "line-height: 1; ");
+    css.push_str(".mid { font-style: normal; }\n");
+    (
+        css,
+        "<div class=\"page\">before <span class=\"mid\">middle</span> after</div>".to_string(),
+        vec![TextCategory::SpanInsideLine],
+        "text-span-inside-line",
+    )
+}
+
+fn recipe_letter_spacing(src: &mut Source) -> (String, String, Vec<TextCategory>, &'static str) {
+    // Including a fractional spacing, because a per-glyph fraction is what accumulates
+    // along a line into a difference the vote can see.
+    let spacing = src.px(&[2.0, 0.5, 1.25]);
+    let css = page_rule(
+        700.0,
+        cases::px(16.0),
+        &format!("line-height: 1; letter-spacing: {}; ", cases::px(spacing)),
+    );
+    (
+        css,
+        "<div class=\"page\">Hamburgefonstiv</div>".to_string(),
+        vec![TextCategory::LetterSpacing],
+        "text-letter-spacing",
+    )
+}
+
+fn recipe_kerning_pair(src: &mut Source) -> (String, String, Vec<TextCategory>, &'static str) {
+    // `AV` and `To` are the pairs a Latin font is most likely to kern. Repeating them
+    // makes any per-pair difference add up rather than hide under the tolerance. Ahem
+    // kerns nothing, so this category is what says whether the two fonts' agreement
+    // figures differ for the reason the spec expects.
+    let size = src.px(&[16.0, 24.0, 40.0]);
+    let css = page_rule(700.0, cases::px(size), "line-height: 1; ");
+    (
+        css,
+        "<div class=\"page\">AVAVAV ToToTo AWAY</div>".to_string(),
+        vec![TextCategory::KerningPair],
+        "text-kerning-pair",
+    )
+}
+
+fn recipe_text_align_center(src: &mut Source) -> (String, String, Vec<TextCategory>, &'static str) {
+    // An odd container width guarantees the leftover space is an odd number of pixels,
+    // so centring it is a division that cannot come out whole.
+    let width = src.px(&[401.0, 333.0, 517.0]);
+    let css = page_rule(width, cases::px(16.0), "line-height: 1; text-align: center; ");
+    (
+        css,
+        "<div class=\"page\">alpha bravo charlie delta echo</div>".to_string(),
+        vec![TextCategory::TextAlignCenter],
+        "text-text-align-center",
+    )
+}
+
+const RECIPES: &[Recipe] = &[
+    recipe_integer_font_size,
+    recipe_fractional_font_size,
+    recipe_wrapping_fixed_width,
+    recipe_line_height_px,
+    recipe_line_height_number,
+    recipe_white_space_pre,
+    recipe_span_inside_line,
+    recipe_letter_spacing,
+    recipe_kerning_pair,
+    recipe_text_align_center,
+];
+
+/// The deterministic set built directly from the category list -- one case per recipe,
+/// mirroring `crate::stacking_cases::enumerated`.
+pub fn enumerated() -> Vec<Case> {
+    RECIPES
+        .iter()
+        .map(|recipe| {
+            let mut src = Source::Fixed;
+            let (css, body, categories, name) = recipe(&mut src);
+            make_case(name, 0, &categories, &css, &body)
+        })
+        .collect()
+}
+
+/// `count` cases sampled over the same grammar as [`enumerated`], mirroring
+/// `crate::stacking_cases::random`.
+pub fn random(seed: u64, count: usize) -> Vec<Case> {
+    let mut rng = ChaCha8Rng::seed_from_u64(seed);
+    (0..count)
+        .map(|i| {
+            let recipe = RECIPES[rng.gen_range(0..RECIPES.len())];
+            let mut src = Source::Random(&mut rng);
+            let (css, body, categories, name) = recipe(&mut src);
+            let id = format!("random-text-{seed:016x}-{i:04}-{name}");
+            make_case(&id, seed, &categories, &css, &body)
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashSet;
+
+    fn every_case() -> Vec<Case> {
+        enumerated().into_iter().chain(random(0x7e47, 40)).collect()
+    }
+
+    #[test]
+    fn enumerated_covers_every_category() {
+        let covered: HashSet<TextCategory> = enumerated()
+            .iter()
+            .flat_map(|c| c.categories.iter().copied())
+            .collect();
+        for category in TextCategory::ALL {
+            assert!(
+                covered.contains(category),
+                "no enumerated case exercises {category:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn enumerated_ids_are_stable() {
+        let ids: Vec<String> = enumerated().into_iter().map(|c| c.id).collect();
+        assert_eq!(
+            ids,
+            vec![
+                "text-integer-font-size",
+                "text-fractional-font-size",
+                "text-wrapping-fixed-width",
+                "text-line-height-px",
+                "text-line-height-number",
+                "text-white-space-pre",
+                "text-span-inside-line",
+                "text-letter-spacing",
+                "text-kerning-pair",
+                "text-text-align-center",
+            ]
+        );
+    }
+
+    #[test]
+    fn every_id_is_unique() {
+        let cases = every_case();
+        let ids: HashSet<&str> = cases.iter().map(|c| c.id.as_str()).collect();
+        assert_eq!(ids.len(), cases.len(), "two cases share an id");
+    }
+
+    #[test]
+    fn same_seed_is_reproducible() {
+        let a: Vec<String> = random(0x5eed, 25).into_iter().map(|c| c.html).collect();
+        let b: Vec<String> = random(0x5eed, 25).into_iter().map(|c| c.html).collect();
+        assert_eq!(a, b);
+    }
+
+    #[test]
+    fn every_case_names_the_pinned_font_and_nothing_else() {
+        for case in every_case() {
+            let declaration = format!("font-family: \"{FONT_FAMILY}\"");
+            assert!(
+                case.html.contains(&declaration),
+                "case {} does not name the pinned font",
+                case.id
+            );
+            // One font-family declaration, and no comma in it: a fallback list would let
+            // a case be measured against a system font, which is the one outcome that
+            // would make every agreement figure meaningless.
+            assert_eq!(
+                case.html.matches("font-family").count(),
+                1,
+                "case {} declares font-family more than once",
+                case.id
+            );
+            let rest = &case.html[case.html.find("font-family").unwrap()..];
+            let value = &rest[..rest.find(';').expect("declaration ends with a semicolon")];
+            assert!(
+                !value.contains(','),
+                "case {} names a fallback font: {value}",
+                case.id
+            );
+        }
+    }
+
+    #[test]
+    fn every_case_carries_the_reset() {
+        for case in every_case() {
+            assert!(
+                case.html.contains(cases::RESET),
+                "case {} is missing the reset",
+                case.id
+            );
+        }
+    }
+
+    #[test]
+    fn every_case_contains_text() {
+        for case in every_case() {
+            let body = &case.html[case.html.find("<body>").unwrap()..];
+            let between_tags: String = body
+                .split('>')
+                .filter_map(|chunk| chunk.split('<').next())
+                .collect();
+            assert!(
+                between_tags.chars().any(|c| c.is_alphanumeric()),
+                "case {} has no text content, so there is nothing for a text probe to measure",
+                case.id
+            );
+        }
+    }
+
+    #[test]
+    fn tag_counts_match_the_metadata() {
+        for case in every_case() {
+            let body = &case.html[case.html.find("<body>").unwrap()..];
+            let opens = body.matches("<div").count() + body.matches("<span").count();
+            let closes = body.matches("</div>").count() + body.matches("</span>").count();
+            assert_eq!(opens, closes, "case {} has unbalanced tags", case.id);
+            assert_eq!(
+                opens, case.element_count,
+                "case {} tag count disagrees with metadata",
+                case.id
+            );
+        }
+    }
+
+    #[test]
+    fn every_case_has_a_head_for_the_font_face_rule() {
+        // The oracle inserts its @font-face rule directly after `<head>`; a case with no
+        // head would get the rule prepended and silently change document mode.
+        for case in every_case() {
+            assert!(
+                case.html.contains("<head>"),
+                "case {} has no <head> for the probe's @font-face rule",
+                case.id
+            );
+        }
+    }
+}
diff --git a/crates/harness/src/trace.rs b/crates/harness/src/trace.rs
index 17b6f01a..b4626386 100644
--- a/crates/harness/src/trace.rs
+++ b/crates/harness/src/trace.rs
@@ -792,6 +792,190 @@ pub fn vote_stacking(
     Ok(StackingVoteReport { points })
 }
 
+// ---------------------------------------------------------------------------------------
+// Text probe: per-line-fragment text geometry
+// ---------------------------------------------------------------------------------------
+
+/// Which text node and quantity one text measurement covers. The element bounding boxes
+/// of the same response are voted by `crate::compare::vote` on `TextDump::geometry()`,
+/// so nothing here duplicates an element metric.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
+pub enum TextMetric {
+    /// How many line fragments the text node broke into. Emitted for every text node;
+    /// when it disagrees there is no aligned pairing, so the per-fragment metrics are
+    /// skipped for that node.
+    FragmentCount,
+    FragmentX(usize),
+    FragmentY(usize),
+    FragmentWidth(usize),
+    FragmentHeight(usize),
+}
+
+/// One voted text measurement. `values` is kept so a report can state how far apart the
+/// engines actually were, not only which bucket they fell in.
+#[derive(Debug, Clone, PartialEq, Serialize)]
+pub struct TextMeasurement {
+    /// Index into `TextDump::texts`.
+    pub text_index: usize,
+    /// The text node's parent element, for naming where a disagreement sits.
+    pub parent: usize,
+    pub metric: TextMetric,
+    pub values: BTreeMap<String, f64>,
+    pub consensus: crate::compare::Consensus,
+}
+
+impl TextMeasurement {
+    /// The largest difference between any two engines on this measurement, in CSS
+    /// pixels. A measurement at or below `dump::TOLERANCE_PX` is unanimous by
+    /// definition; above it, this says by how much.
+    pub fn spread(&self) -> f64 {
+        let mut min = f64::INFINITY;
+        let mut max = f64::NEG_INFINITY;
+        for &v in self.values.values() {
+            min = min.min(v);
+            max = max.max(v);
+        }
+        if min.is_finite() && max.is_finite() {
+            max - min
+        } else {
+            0.0
+        }
+    }
+
+    pub fn is_trustworthy(&self) -> bool {
+        !matches!(self.consensus, crate::compare::Consensus::Split)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize)]
+pub struct TextVoteReport {
+    pub measurements: Vec<TextMeasurement>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum TextVoteError {
+    TooFewEngines(usize),
+    /// Engines disagreed on how many text nodes the document has at all, which is a
+    /// parse-tree difference rather than a geometry one and is not something a
+    /// per-measurement vote can absorb.
+    TextCountMismatch {
+        engine: String,
+        expected: usize,
+        found: usize,
+    },
+}
+
+/// The same pairwise-agreement rule `crate::compare::classify` applies to element
+/// geometry, over values that are not `Dump` nodes and so cannot go through
+/// `compare::vote`: unanimous when every pair agrees within `dump::TOLERANCE_PX`, a
+/// named outlier when all but one engine agree with each other and that one agrees with
+/// none of them, otherwise a full split.
+fn classify_text(values: &BTreeMap<String, f64>) -> crate::compare::Consensus {
+    use crate::compare::Consensus;
+
+    let entries: Vec<(&str, f64)> = values.iter().map(|(k, v)| (k.as_str(), *v)).collect();
+    let agrees = |a: f64, b: f64| (a - b).abs() <= crate::dump::TOLERANCE_PX;
+
+    if entries
+        .iter()
+        .all(|&(_, v)| entries.iter().all(|&(_, v2)| agrees(v, v2)))
+    {
+        return Consensus::Unanimous;
+    }
+
+    for &(name, value) in &entries {
+        let others: Vec<(&str, f64)> =
+            entries.iter().copied().filter(|&(n, _)| n != name).collect();
+        let outlier_disagrees_with_all = others.iter().all(|&(_, v)| !agrees(value, v));
+        let others_agree = others
+            .iter()
+            .all(|&(_, v1)| others.iter().all(|&(_, v2)| agrees(v1, v2)));
+        if outlier_disagrees_with_all && others_agree {
+            return Consensus::Majority {
+                outlier: name.to_string(),
+            };
+        }
+    }
+
+    Consensus::Split
+}
+
+/// One of a line fragment's four measured quantities, as a reader of the rect.
+type RectField = fn(&crate::dump::Rect) -> f64;
+
+/// Classifies every text-node measurement across three or more engines' text probes
+/// (`docs/dump-format.md` -> "Text probe" -> "Comparison"). A text node that produced no
+/// line box in any engine -- the contents of `<style>`, among others -- contributes its
+/// unanimous fragment count and nothing else, since it has no geometry to measure.
+pub fn vote_text(
+    results: &BTreeMap<String, crate::dump::TextDump>,
+) -> Result<TextVoteReport, TextVoteError> {
+    if results.len() < 3 {
+        return Err(TextVoteError::TooFewEngines(results.len()));
+    }
+
+    let mut iter = results.values();
+    let first = iter.next().expect("checked len >= 3 above");
+    let expected = first.texts.len();
+    for (name, result) in results.iter().skip(1) {
+        if result.texts.len() != expected {
+            return Err(TextVoteError::TextCountMismatch {
+                engine: name.clone(),
+                expected,
+                found: result.texts.len(),
+            });
+        }
+    }
+
+    let collect = |i: usize, f: &dyn Fn(&crate::dump::TextRun) -> f64| -> BTreeMap<String, f64> {
+        results
+            .iter()
+            .map(|(name, r)| (name.clone(), f(&r.texts[i])))
+            .collect()
+    };
+
+    let mut measurements = Vec::new();
+    for i in 0..expected {
+        let parent = first.texts[i].parent;
+        let counts = collect(i, &|t| t.rects.len() as f64);
+        let count_consensus = classify_text(&counts);
+        let counts_agree = matches!(count_consensus, crate::compare::Consensus::Unanimous);
+        let fragments = first.texts[i].rects.len();
+        measurements.push(TextMeasurement {
+            text_index: i,
+            parent,
+            metric: TextMetric::FragmentCount,
+            values: counts,
+            consensus: count_consensus,
+        });
+
+        if !counts_agree {
+            continue;
+        }
+        for f in 0..fragments {
+            let per_fragment: [(TextMetric, RectField); 4] = [
+                (TextMetric::FragmentX(f), |r| r.x),
+                (TextMetric::FragmentY(f), |r| r.y),
+                (TextMetric::FragmentWidth(f), |r| r.w),
+                (TextMetric::FragmentHeight(f), |r| r.h),
+            ];
+            for (metric, get) in per_fragment {
+                let values = collect(i, &|t| get(&t.rects[f]));
+                let consensus = classify_text(&values);
+                measurements.push(TextMeasurement {
+                    text_index: i,
+                    parent,
+                    metric,
+                    values,
+                    consensus,
+                });
+            }
+        }
+    }
+
+    Ok(TextVoteReport { measurements })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1091,4 +1275,154 @@ mod tests {
             other => panic!("expected CountMismatch, got {other:?}"),
         }
     }
+
+    fn text_run(parent: usize, rects: &[(f64, f64, f64, f64)]) -> crate::dump::TextRun {
+        crate::dump::TextRun {
+            parent,
+            text: "word".to_string(),
+            truncated: false,
+            rects: rects
+                .iter()
+                .map(|&(x, y, w, h)| crate::dump::Rect { x, y, w, h })
+                .collect(),
+        }
+    }
+
+    fn text_dump(engine: &str, texts: Vec<crate::dump::TextRun>) -> crate::dump::TextDump {
+        crate::dump::TextDump {
+            engine: engine.to_string(),
+            engine_version: "0".to_string(),
+            font: "ahem".to_string(),
+            font_sha256: "0".repeat(64),
+            font_family: "probe".to_string(),
+            viewport: crate::dump::Viewport {
+                width: 800,
+                height: 600,
+            },
+            overflowed: false,
+            nodes: Vec::new(),
+            texts,
+        }
+    }
+
+    fn three_texts(
+        texts: [Vec<crate::dump::TextRun>; 3],
+    ) -> BTreeMap<String, crate::dump::TextDump> {
+        [
+            ("chromium".to_string(), text_dump("chromium", texts[0].clone())),
+            ("firefox".to_string(), text_dump("firefox", texts[1].clone())),
+            ("webkit".to_string(), text_dump("webkit", texts[2].clone())),
+        ]
+        .into_iter()
+        .collect()
+    }
+
+    #[test]
+    fn vote_text_counts_one_measurement_per_fragment_quantity() {
+        let runs = vec![text_run(1, &[(0.0, 0.0, 64.0, 16.0)])];
+        let report = vote_text(&three_texts([runs.clone(), runs.clone(), runs])).unwrap();
+        // One fragment count plus x, y, width and height for the single fragment.
+        assert_eq!(report.measurements.len(), 5);
+        assert!(report
+            .measurements
+            .iter()
+            .all(|m| m.consensus == crate::compare::Consensus::Unanimous));
+    }
+
+    #[test]
+    fn vote_text_absorbs_a_difference_below_the_tolerance() {
+        // 1/64 px apart: the grid Chromium and WebKit round to, finer than the 1/60 the
+        // vote calls agreement, so this is noise and not disagreement.
+        let report = vote_text(&three_texts([
+            vec![text_run(1, &[(0.0, 0.0, 64.0, 16.0)])],
+            vec![text_run(1, &[(0.0, 0.0, 64.0 + 1.0 / 64.0, 16.0)])],
+            vec![text_run(1, &[(0.0, 0.0, 64.0, 16.0)])],
+        ]))
+        .unwrap();
+        let width = report
+            .measurements
+            .iter()
+            .find(|m| m.metric == TextMetric::FragmentWidth(0))
+            .unwrap();
+        assert_eq!(width.consensus, crate::compare::Consensus::Unanimous);
+    }
+
+    #[test]
+    fn vote_text_names_the_outlier_on_a_two_one_split() {
+        let report = vote_text(&three_texts([
+            vec![text_run(1, &[(0.0, 0.0, 64.0, 16.0)])],
+            vec![text_run(1, &[(0.0, 0.0, 65.0, 16.0)])],
+            vec![text_run(1, &[(0.0, 0.0, 64.0, 16.0)])],
+        ]))
+        .unwrap();
+        let width = report
+            .measurements
+            .iter()
+            .find(|m| m.metric == TextMetric::FragmentWidth(0))
+            .unwrap();
+        assert_eq!(
+            width.consensus,
+            crate::compare::Consensus::Majority {
+                outlier: "firefox".to_string()
+            }
+        );
+        assert_eq!(width.spread(), 1.0);
+    }
+
+    #[test]
+    fn vote_text_skips_fragment_metrics_when_the_line_count_disagrees() {
+        // Two engines break the text into two lines and one into one. There is no
+        // aligned pairing to vote on, so only the count itself is measured.
+        let report = vote_text(&three_texts([
+            vec![text_run(1, &[(0.0, 0.0, 64.0, 16.0), (0.0, 16.0, 32.0, 16.0)])],
+            vec![text_run(1, &[(0.0, 0.0, 96.0, 16.0)])],
+            vec![text_run(1, &[(0.0, 0.0, 64.0, 16.0), (0.0, 16.0, 32.0, 16.0)])],
+        ]))
+        .unwrap();
+        assert_eq!(report.measurements.len(), 1);
+        assert_eq!(report.measurements[0].metric, TextMetric::FragmentCount);
+        assert_eq!(
+            report.measurements[0].consensus,
+            crate::compare::Consensus::Majority {
+                outlier: "firefox".to_string()
+            }
+        );
+    }
+
+    #[test]
+    fn vote_text_measures_nothing_but_the_count_for_a_text_node_with_no_line_box() {
+        // The contents of `<style>`: present in document order, no geometry.
+        let runs = vec![text_run(2, &[])];
+        let report = vote_text(&three_texts([runs.clone(), runs.clone(), runs])).unwrap();
+        assert_eq!(report.measurements.len(), 1);
+        assert_eq!(report.measurements[0].metric, TextMetric::FragmentCount);
+    }
+
+    #[test]
+    fn vote_text_requires_at_least_three_engines() {
+        let results: BTreeMap<String, crate::dump::TextDump> = [
+            ("chromium".to_string(), text_dump("chromium", vec![])),
+            ("firefox".to_string(), text_dump("firefox", vec![])),
+        ]
+        .into_iter()
+        .collect();
+        assert_eq!(vote_text(&results), Err(TextVoteError::TooFewEngines(2)));
+    }
+
+    #[test]
+    fn vote_text_rejects_a_differing_text_node_count() {
+        let results = three_texts([
+            vec![text_run(1, &[])],
+            vec![text_run(1, &[]), text_run(2, &[])],
+            vec![text_run(1, &[])],
+        ]);
+        assert_eq!(
+            vote_text(&results),
+            Err(TextVoteError::TextCountMismatch {
+                engine: "firefox".to_string(),
+                expected: 1,
+                found: 2,
+            })
+        );
+    }
 }
diff --git a/docs/dump-format.md b/docs/dump-format.md
index df76c41e..40ced7f9 100644
--- a/docs/dump-format.md
+++ b/docs/dump-format.md
@@ -451,3 +451,95 @@ paint order at a point is either exactly right or wrong, so there is no toleranc
 no named-outlier majority the way `compare::vote`/`trace::vote` allow for geometry
 (agreement is exact-match, not a numeric closeness check). A point without unanimous
 agreement is dropped and counted, not guessed at.
+
+## Text probe
+
+Additive, the same way the stacking probe is: everything above is unchanged, and
+`textProbe` is a new request operation with its own response shape. It exists because
+every other corpus here is text-free by construction, so nothing had measured whether the
+engines agree on geometry once glyphs are involved (`specs/text-metrics-oracle.md`,
+`docs/text-metrics.md`). Scope: Latin text in one writing mode. Out: shaping beyond
+Latin, bidi, vertical writing modes, system fonts and text painting.
+
+### Request
+
+```json
+{"id": "t1", "op": "textProbe", "html": "...", "font": "ahem", "engines": ["chromium", "firefox", "webkit"]}
+```
+
+- `html` (required): the document to render, same as the base request's own `html`. It
+  must carry a `<head>`; see "The font" below.
+- `font` (required): which pinned font to measure in, `ahem` or `lato`. An unknown key,
+  or a key whose file is not in the checkout, fails the whole request rather than one
+  engine, and the message names `node oracle/suites/fetch.mjs wpt`.
+- `engines` (optional): as in the base request -- omitted means every launched engine.
+
+### The font
+
+The oracle reads the font's bytes from the WPT checkout `oracle/suites/suites.json`
+pins, whose sparse list already fetches `/fonts/`, and inserts an `@font-face` rule
+carrying them as a `data:` URL directly after the document's `<head>`, so the page stays
+self-contained under `page.setContent` with no network fetch. The rule goes inside the
+head rather than ahead of the document string because a `<style>` before `<!doctype html>`
+would make the doctype content and drop the page into quirks mode, changing the geometry
+being measured.
+
+The family is always `probe`, whichever font key was requested, so a case's markup is
+identical in both fonts and the only thing that varies is the bytes. Before any
+measurement the oracle calls `document.fonts.load()`, waits for `document.fonts.ready`,
+and fails that engine's request unless a `FontFace` for `probe` exists in the document
+and every such face reports `status: "loaded"`. `document.fonts.check()` is checked too
+but cannot carry this alone: for a family with no matching `@font-face` it reports the
+system fallback as available, so it answers "true" in exactly the case that must fail. A
+silently substituted fallback font would make every agreement figure meaningless, so an
+engine that fell back appears in `errors`, never in `results`.
+
+### Response
+
+```json
+{"id": "t1", "results": {"chromium": {"engine": "chromium", "engine_version": "...", "font": "ahem", "font_sha256": "b719ec...", "font_family": "probe", "viewport": {"width": 800, "height": 600}, "overflowed": false, "nodes": [], "texts": []}}, "errors": {"webkit": "message"}}
+```
+
+`results` is keyed by engine name, one entry per engine that answered; `errors` (omitted
+when empty) carries a message per engine that did not.
+
+- `nodes`, `viewport` and `overflowed` are exactly what an ordinary dump carries, with
+  the same meaning, produced by the same walk. `crates/harness/src/dump.rs`
+  `TextDump::geometry()` hands that half back as a plain `Dump`, so element bounding
+  boxes go through `compare::vote()` unchanged.
+- `font` echoes the request's key; `font_sha256` is the sha256 of the file actually
+  embedded, so a figure is tied to exact bytes rather than to a file name.
+- `texts` is every text node in the document, in document order.
+
+### Per-text-node result
+
+```json
+{"parent": 5, "text": "alpha bravo", "truncated": false, "rects": [{"x": 0, "y": 0, "w": 176, "h": 16}]}
+```
+
+- `parent`: the index into `nodes` of the element this text node is a child of. It is
+  the same index the element dump uses, recomputed by the same ordering rule (pre-order
+  from `document.documentElement`, children in order).
+- `text`: the node's data, truncated to 64 characters with `truncated` set when it was.
+  Only the rects are measured; the text is carried so a stored response can be read, and
+  a text probe's document holds the font's several-hundred-kilobyte `data:` URL as one
+  text node.
+- `rects`: `Range.getClientRects()` over the node's contents -- one rect per line
+  fragment, in line order. Empty for a text node that generates no line box, which
+  includes the contents of every `<style>` in the document, the injected `@font-face`
+  rule among them.
+
+### Comparison
+
+`crates/harness/src/trace.rs` `vote_text()`, using `compare::Consensus` and
+`dump::TOLERANCE_PX` = 1/60 px: the same pairwise rule element geometry is voted by, over
+values that are not `Dump` nodes and so cannot go through `compare::vote()` directly.
+Fragment count is voted for every text node; when it disagrees there is no aligned
+pairing, so the per-fragment `x`, `y`, `w` and `h` are skipped for that node and only the
+count is reported. Engines that disagree on how many text nodes the document has at all
+are a parse-tree difference rather than a geometry one, and are rejected
+(`TextVoteError::TextCountMismatch`) rather than absorbed.
+
+`crates/harness/src/bin/text_metrics.rs` is what runs this over a corpus; it drops a text
+node that produced no line box in any engine rather than counting it as agreement about
+geometry that does not exist.
diff --git a/docs/text-metrics.md b/docs/text-metrics.md
new file mode 100644
index 00000000..56be8238
--- /dev/null
+++ b/docs/text-metrics.md
@@ -0,0 +1,283 @@
+# Do the three engines agree on text geometry?
+
+Partly, and the part they disagree on is sharply localized. Every other corpus this
+project checks the engine against is text-free by construction
+(`crates/harness/src/cases.rs`'s module doc) and the held-out WPT filter
+(`oracle/suites/normal-flow-pages.mjs`) rejects any page with a text node, so until now
+nothing had measured whether Chromium, Firefox and WebKit place glyphs closely enough for
+the geometry vote (`docs/geometry-verification.md`) to run at all. This is that
+measurement. It builds no layout code.
+
+**The short answer.** Line breaking and element geometry are votable; the text fragment
+rect is not. All three engines broke every line at the same place in both fonts, and the
+element boxes of a text-bearing page agree at 1/60 px 99–100% of the time. But the rect a
+text node's own line fragment occupies disagrees systematically: Firefox makes it 1 px
+taller than the other two almost always, and in the proportional font the three engines
+never once agreed on a line's width. Loosening the tolerance does not rescue it — the
+differences are whole-pixel-scale, not sub-pixel.
+
+```mermaid
+flowchart TD
+  probe["textProbe:<br/>pinned font, 3 engines"] --> lines{"same number<br/>of line fragments?"}
+  lines -- "yes, 100% of the time<br/>in both fonts" --> boxes{"element boxes<br/>within 1/60 px?"}
+  boxes -- "yes, 99-100%" --> ok["element geometry of a<br/>text-bearing page: votable"]
+  boxes --> frag{"text fragment rect<br/>within 1/60 px?"}
+  frag -- "x: yes in Ahem, 81.7% in Lato<br/>width: 96.6% in Ahem, 0% in Lato" --> horiz["horizontal: font-dependent"]
+  frag -- "y and height: 4-9%" --> vert["vertical: no, in either font"]
+```
+
+## What was measured
+
+- **Probe**: `docs/dump-format.md` → "Text probe". One request renders a document with a
+  pinned font embedded as a `data:` URL and returns, per engine, the ordinary element dump
+  plus every text node's `Range.getClientRects()` — one rect per line fragment. An engine
+  whose page fell back to a system font fails the request rather than being measured, so
+  no figure here is contaminated by font substitution.
+- **Cases**: `crates/harness/src/text_cases.rs`, ten categories (`TextCategory::ALL`), each
+  run in both fonts with byte-identical markup. The run below is `enumerated()` plus 60
+  seeded-random cases at seed `0x7e47`, so 70 cases per font.
+- **Quantities**: each element's bounding box and per-fragment rects, voted by
+  `crates/harness/src/compare.rs` `vote()`; each text node's fragment count and per-fragment
+  x, y, width and height, voted by `crates/harness/src/trace.rs` `vote_text()`. Both use
+  `Consensus` at `dump::TOLERANCE_PX` = 1/60 px.
+- **Binary**: `crates/harness/src/bin/text_metrics.rs`. Raw responses are kept under
+  `corpus/text-metrics/<font>/<case>.json` (gitignored) so a rerun on other engine versions
+  can be diffed against this one.
+
+A text node that produced no line box in any engine — the contents of every `<style>`,
+including the injected `@font-face` rule — is reported by the probe but dropped from these
+tallies rather than counted as agreement about geometry that does not exist.
+
+### Engines
+
+From Playwright, launched with the oracle's `default` profile on Linux:
+
+| Engine | Version |
+|---|---|
+| Chromium | 153.0.8010.12 |
+| Firefox | 155.0 |
+| WebKit | 26.6 |
+
+Every number below is valid only for these builds. The vote's tolerance, 1/60 px, is the
+coarsest grid any of them rounds to (Firefox's app units); Chromium and WebKit use 1/64.
+
+### Fonts
+
+Both are files in the WPT checkout `oracle/suites/suites.json` pins (commit
+`26f417a8c0`), whose sparse list already fetches `/fonts/`.
+
+| Key | File | Version | License | sha256 |
+|---|---|---|---|---|
+| `ahem` | `fonts/Ahem.ttf` | 1.50 | Public domain, with a Creative Commons fallback for jurisdictions that do not recognize it (stated in the font's own name table; `http://dev.w3.org/CSS/fonts/ahem/COPYING`) | `b719ecb31c5b21fc573c03f6421c74ac63c271a5a3ff841e34f9705fb94b8448` |
+| `lato` | `fonts/Lato-Medium.ttf` | 2.015 | SIL Open Font License 1.1, © 2011–2015 tyPoland Lukasz Dziedzic, reserved font name "Lato" (stated in the font's own name table) | `be8bbf7105500e8fc1f9429307fb396905a0e6cff63fe1eb751bb319d0f1b0db` |
+
+Ahem's every glyph is a 1 em square and it is the font WPT's own text-bearing layout tests
+use, so it is the case most likely to agree. Lato is proportional, with real advances,
+kerning pairs and hinting; it was chosen over the other proportional faces in that
+directory because it is a TrueType file rather than a WOFF, so the ordinary hinting path is
+exercised, and because it states its own license, which is where the license above was read
+from rather than assumed.
+
+## Ahem
+
+3581 measurements over 70 cases. 91.6% unanimous, 8.0% 2-1, 0.4% split.
+
+| Category | Voted | Unanimous | 2-1 | Split | Max delta px |
+|---|---|---|---|---|---|
+| one word, integer font size | 322 | 95.7% | 4.3% | 0.0% | 1.000000 |
+| one word, fractional font size | 230 | 95.2% | 4.3% | 0.4% | 7.500458 |
+| wrapping at a fixed width | 534 | 85.4% | 14.6% | 0.0% | 1.000000 |
+| `line-height` in px | 540 | 88.9% | 8.3% | 2.8% | 1.000000 |
+| `line-height` as a number | 270 | 88.9% | 11.1% | 0.0% | 1.000000 |
+| `white-space: pre` | 276 | 97.1% | 2.9% | 0.0% | 1.000000 |
+| `<span>` inside a line | 315 | 85.7% | 14.3% | 0.0% | 1.000000 |
+| `letter-spacing` | 414 | 95.7% | 4.3% | 0.0% | 1.000000 |
+| kerning pair | 238 | 97.5% | 2.5% | 0.0% | 1.000000 |
+| `text-align: center` | 442 | 92.8% | 7.2% | 0.0% | 1.000000 |
+| **all** | **3581** | **91.6%** | **8.0%** | **0.4%** | **7.500458** |
+
+The per-category view is misleading on its own: the disagreement is not spread across
+categories, it is one quantity appearing in all of them. Grouped by what was measured
+rather than by which case measured it:
+
+| Quantity | Voted | Unanimous | 2-1 | Split | Max delta px | Outlier |
+|---|---|---|---|---|---|---|
+| element x | 495 | 100.0% | 0.0% | 0.0% | 0.000748 | — |
+| element y | 495 | 99.0% | 1.0% | 0.0% | 0.500000 | firefox ×5 |
+| element width | 495 | 100.0% | 0.0% | 0.0% | 0.000641 | — |
+| element height | 495 | 99.0% | 1.0% | 0.0% | 1.000000 | firefox ×5 |
+| element fragment count | 495 | 100.0% | 0.0% | 0.0% | 0.000000 | — |
+| element fragment width | 215 | 100.0% | 0.0% | 0.0% | 0.000641 | — |
+| element fragment height | 215 | 97.7% | 2.3% | 0.0% | 1.000000 | firefox ×5 |
+| text fragment count | 80 | 100.0% | 0.0% | 0.0% | 0.000000 | — |
+| text fragment x | 149 | 100.0% | 0.0% | 0.0% | 0.001389 | — |
+| **text fragment y** | 149 | **4.0%** | 85.9% | 10.1% | 0.875000 | firefox ×124, chromium ×4 |
+| text fragment width | 149 | 96.6% | 2.7% | 0.7% | 7.500458 | chromium ×4 |
+| **text fragment height** | 149 | **6.7%** | 93.3% | 0.0% | 1.000000 | firefox ×139 |
+
+**Firefox reports the text fragment one pixel taller, and half a pixel higher, than the
+other two.** One word at 16px, the simplest case in the corpus:
+
+| Engine | fragment y | fragment height | fragment width |
+|---|---|---|---|
+| Chromium | 0.0 | 16.0 | 240.0 |
+| Firefox | −0.5 | 17.0 | 240.0 |
+| WebKit | 0.0 | 16.0 | 240.00045776367188 |
+
+The widths agree to 0.00046 px, well inside the tolerance. The height does not, and it is
+the same 1 px in essentially every case — which is why `text fragment height` is unanimous
+only 6.7% of the time while every horizontal quantity is unanimous 96.6% or better.
+
+**The 7.5 px outlier is Chromium rounding glyph advances to whole pixels at a fractional
+font size.** "Hamburgefonstiv" (15 glyphs) at `font-size: 13.5px`:
+
+| Engine | fragment width | per glyph |
+|---|---|---|
+| Chromium | 210.0 | 14.0 |
+| Firefox | 202.5 | 13.5 |
+| WebKit | 202.49954223632812 | 13.499969… |
+
+Firefox and WebKit keep the fractional em advance; Chromium rounds it up to the next whole
+pixel and the error multiplies by the glyph count. This is the only place in Ahem where a
+horizontal quantity leaves the tolerance, and it needs a font size that is not a whole
+pixel — the same precondition `docs/firefox-app-units.md` found for the box-geometry
+divergence, with a different engine as the outlier.
+
+## Lato
+
+3401 measurements over 70 cases. 90.1% unanimous, 7.7% 2-1, 2.2% split.
+
+| Category | Voted | Unanimous | 2-1 | Split | Max delta px |
+|---|---|---|---|---|---|
+| one word, integer font size | 322 | 93.5% | 6.2% | 0.3% | 1.000000 |
+| one word, fractional font size | 230 | 94.3% | 1.7% | 3.9% | 4.949997 |
+| wrapping at a fixed width | 450 | 88.0% | 10.0% | 2.0% | 2.185547 |
+| `line-height` in px | 500 | 88.0% | 8.0% | 4.0% | 1.000000 |
+| `line-height` as a number | 250 | 88.0% | 10.0% | 2.0% | 1.000000 |
+| `white-space: pre` | 276 | 94.9% | 2.9% | 2.2% | 1.000000 |
+| `<span>` inside a line | 315 | 78.7% | 18.1% | 3.2% | 1.812607 |
+| `letter-spacing` | 414 | 93.5% | 6.5% | 0.0% | 1.000000 |
+| kerning pair | 230 | 93.5% | 4.3% | 2.2% | 3.793808 |
+| `text-align: center` | 414 | 91.3% | 6.5% | 2.2% | 1.000000 |
+| **all** | **3401** | **90.1%** | **7.7%** | **2.2%** | **4.949997** |
+
+| Quantity | Voted | Unanimous | 2-1 | Split | Max delta px | Outlier |
+|---|---|---|---|---|---|---|
+| element x | 495 | 99.0% | 1.0% | 0.0% | 1.812607 | chromium ×5 |
+| element y | 495 | 99.4% | 0.6% | 0.0% | 0.500000 | webkit ×3 |
+| element width | 495 | 99.0% | 0.6% | 0.4% | 0.400009 | chromium ×3 |
+| element height | 495 | 99.4% | 0.6% | 0.0% | 1.000000 | firefox ×3 |
+| element fragment count | 495 | 100.0% | 0.0% | 0.0% | 0.000000 | — |
+| element fragment width | 215 | 97.7% | 1.4% | 0.9% | 0.400009 | chromium ×3 |
+| element fragment height | 215 | 98.6% | 1.4% | 0.0% | 1.000000 | firefox ×3 |
+| text fragment count | 80 | 100.0% | 0.0% | 0.0% | 0.000000 | — |
+| text fragment x | 104 | 81.7% | 14.4% | 3.8% | 1.812607 | chromium ×15 |
+| **text fragment y** | 104 | **8.7%** | 77.9% | 13.5% | 0.750000 | webkit ×77, firefox ×4 |
+| **text fragment width** | 104 | **0.0%** | 50.0% | 50.0% | 4.949997 | chromium ×52 |
+| **text fragment height** | 104 | **8.7%** | 91.3% | 0.0% | 1.000000 | firefox ×95 |
+
+**The three engines never once agreed on a line's width in Lato.** Not one of the 104
+measurements was unanimous; half were 2-1 with Chromium named, and the other half were
+three-way splits with no reference value at all. The kerning case at 16px shows all three
+mechanisms at once:
+
+| Engine | fragment width | fragment y | fragment height |
+|---|---|---|---|
+| Chromium | 157.0 | −2.0 | 19.0 |
+| Firefox | 159.51666259765625 | −2.0 | 20.0 |
+| WebKit | 160.52565002441406 | −1.5 | 19.0 |
+
+Chromium's whole-pixel rounding of the run width, seen in Ahem only at fractional font
+sizes, applies to *every* line in a proportional font, because a proportional advance is
+essentially never a whole pixel. That alone would leave a 2-1 vote with Chromium as the
+standing outlier. But Firefox and WebKit are 1.01 px apart from each other as well — they
+do not apply this font's kerning identically — so the measurement is a three-way split half
+the time.
+
+`<span>` inside a line is the worst category (78.7% unanimous) for the same reason: the
+span's position depends on the width of the text before it, so a width difference becomes a
+position difference for everything after it on the line.
+
+## Loosening the tolerance does not help
+
+A measurement is unanimous at tolerance *T* exactly when the spread between the extreme
+engines is at most *T*, so one pass over the stored spreads answers the question for every
+*T* at once:
+
+| Tolerance | Ahem | Lato |
+|---|---|---|
+| 1/60 px (the vote) | 89.95% | 88.08% |
+| 0.125 px | 89.95% | 88.39% |
+| 0.25 px | 89.95% | 89.84% |
+| 0.5 px | 94.28% | 93.98% |
+| 1 px | 99.87% | 98.62% |
+| 2 px | 99.87% | 99.43% |
+| 4 px | 99.87% | 99.86% |
+| 8 px | 100.00% | 100.00% |
+
+Going from 1/60 px to 0.25 px — fifteen times looser — buys nothing in Ahem and 1.8 points
+in Lato, because the disagreements are not sub-pixel. Reaching 99% needs a 1 px tolerance,
+sixty times the vote's, at which point the vote can no longer distinguish a correct box
+from one that is a whole pixel wrong; that is not a tolerance, it is giving up on geometry
+verification. Full agreement needs 8 px in both fonts.
+
+## Verdict
+
+**Ahem: yes at 1/60 px, with Firefox a standing named outlier on the fragment's vertical
+extent.** The vote's own bar is not unanimity — `compare::vote` accepts a 2-1 majority and
+takes the pair's value as the reference, skipping only a full split. By that bar 99.6% of
+Ahem measurements carry a trustworthy reference. A text-bearing generated function can be
+scored against a three-engine vote in Ahem, provided two things are understood: the
+reference for `text fragment y` and `text fragment height` will come from a Chromium–WebKit
+pair with Firefox outvoted about 90% of the time, which is a much weaker guarantee than the
+unanimity element geometry enjoys; and fractional font sizes must be avoided or Chromium
+becomes an outlier on width too.
+
+**Lato: no.** Half of all `text fragment width` measurements are three-way splits, so half
+of the horizontal geometry of a line has no reference value at any tolerance the vote could
+adopt. The other half yields only a Firefox–WebKit pair, and those two are themselves over
+a pixel apart on kerned text. A generated function whose output is a line's width, a
+glyph's advance, or the position of anything after text on a line cannot be scored against
+this vote in a proportional font. Element geometry of the same pages remains votable at
+99%+, so a function that consumes text only as an opaque inline box still can be.
+
+**What both fonts agree on, and it matters:** line breaking. `text fragment count` and
+`element fragment count` were unanimous in 100% of measurements in both fonts, across the
+wrapping, `white-space: pre`, `letter-spacing` and `text-align: center` categories — the
+engines never once disagreed about how many lines a text node broke into or where the
+breaks fell. Where a line *starts* and how *tall* it is are contested; *whether* it starts
+is not.
+
+### What this blocks
+
+Against `docs/platform-areas.md` → "Text and internationalization" → "Text rendering (font
+loading and fallback, shaping, line breaking and hyphenation, glyph rasterization)":
+
+- **Blocked in a proportional font**: shaping and glyph advances. The measured quantity —
+  the advance width of a run of Latin text — has no three-engine reference value half the
+  time, so a generated shaping or advance-measurement function cannot be scored against this
+  vote. This is the number, not a softening of it: 0 of 104 measurements unanimous.
+- **Blocked in both fonts**: the vertical extent of a line box as `Range.getClientRects()`
+  reports it. Firefox differs by a whole pixel from Chromium and WebKit in over 90% of
+  measurements, in Ahem as much as in Lato.
+- **Not blocked**: line breaking. It is the one part of that row this vote can carry today,
+  in both fonts, at 1/60 px.
+- **Not blocked**: the element geometry of pages that contain text. A text-bearing document
+  does not degrade the box-geometry vote — 99–100% unanimous, maximum difference 0.0007 px
+  on element width in Ahem. The text-free corpora were a simplification, not a necessity, as
+  far as element boxes are concerned.
+
+An oracle that could score shaping would have to be something other than a three-engine
+geometry vote — the engines do not agree, so there is nothing for a vote to find.
+
+## Reproducing
+
+```
+cargo run --release -p harness --bin text_metrics -- --random 60 --seed 0x7e47
+```
+
+It needs the pinned WPT checkout; `node oracle/suites/fetch.mjs wpt` fetches it if the
+fonts are missing, and the probe says so by name rather than measuring something else.
+`node oracle/selftest.mjs --engines=chromium,firefox,webkit` checks the probe end to end,
+including that the pinned Ahem really loaded — two of its glyphs at 100px are exactly 200px
+wide, which no substituted font would produce.
diff --git a/handoff.md b/handoff.md
index ff466423..a7e8c5b4 100644
--- a/handoff.md
+++ b/handoff.md
@@ -15,47 +15,82 @@ enough for a vote — is a valid deliverable.
 
 ## Current state
 
-Nothing implemented. Branch `track/spec-text-metrics-oracle` is at `main` plus this
-handoff. The spec depends on `overflow-scrollbars`, which has landed, so
-`oracle/oracle.mjs` and `docs/dump-format.md` already carry that spec's changes.
+The spec is implemented and the measurement has been run; `docs/text-metrics.md` carries
+the result. Nothing in the spec is left unbuilt. What exists:
+
+- `oracle/oracle.mjs` — the `textProbe` operation (`handleTextRequest`,
+  `Engine.textProbe`, the in-page `fontProbe` and `textDump`, plus `loadProbeFont` and
+  `withFontFace`).
+- `oracle/selftest.mjs` — the text-probe checks, at the end of `main` before `shutdown`.
+- `docs/dump-format.md` — the "Text probe" section.
+- `crates/harness/src/dump.rs` — `TextRun`, `TextRequest`, `TextDump` (with
+  `TextDump::geometry()`), `TextResponse`, and a `mod tests` that parses a recorded
+  response.
+- `crates/harness/src/oracle.rs` — `Oracle::text_probe()`.
+- `crates/harness/src/trace.rs` — `vote_text()`, `TextMetric`, `TextMeasurement`
+  (with `spread()`), `TextVoteReport`, `TextVoteError`, and seven tests.
+- `crates/harness/src/text_cases.rs` — `TextCategory` (`ALL`, `name()`), `Case`,
+  `enumerated()`, `random(seed, count)`, and nine tests.
+- `crates/harness/src/bin/text_metrics.rs` — the measurement binary.
+- `docs/text-metrics.md`, and the appended `roadmap.md` entry under "Oracle expansion —
+  in parallel with Phase 1".
 
 ## Next steps
 
-1. Add a `textProbe` operation to `oracle/oracle.mjs`, beside the existing
-   `stackingProbe`. The request carries `html` and a font key (`ahem` or the proportional
-   font's key). It reads that font's bytes from the pinned WPT checkout, prepends an
-   `@font-face` rule with a `data:` URL so the page stays self-contained under
-   `page.setContent`, waits for `document.fonts.ready`, and fails the request if
-   `document.fonts.check()` says the face did not load. If the font is missing, the error
-   names `node oracle/suites/fetch.mjs wpt`.
-2. Make the response carry, per engine, the element dump `domDump` already produces, plus
-   for every text node in document order its parent element's index and
-   `Range.getClientRects()` (one rect per line fragment), plus the font's sha256.
-3. Add one check to `oracle/selftest.mjs`: the probe answers, and the font loaded in every
-   engine.
-4. Add a "Text probe" section to `docs/dump-format.md` in the form of the existing
-   "Stacking probe" section (request, response, per-text-node result, comparison).
-5. Add the request and response types and an `Oracle::text_probe()` method in
-   `crates/harness/src/dump.rs` and `crates/harness/src/oracle.rs`, shaped like
-   `Oracle::stacking_probe()`.
-6. Write `crates/harness/src/text_cases.rs` with its own `Category` enum (`pub const ALL`),
-   `Case`, `enumerated()` and `random(seed, count)`. It writes its own markup rather than
-   using `cases::Elem`, which renders only empty `<div>`s, and reuses `cases::RESET`.
-   Categories at least: one word at an integer font size; one word at a fractional font
-   size (`13.5px`, `17.03125px`); several words wrapping at a fixed container width;
-   explicit `line-height` in px and as a number; `white-space: pre` with repeated spaces; a
-   `<span>` inside a line (its element rects); `letter-spacing`; a kerning pair (`AV`,
-   `To`) in the proportional font; and `text-align: center`. Each category runs in both
-   fonts.
-7. Write `crates/harness/src/bin/text_metrics.rs`: run every case through `textProbe`, vote
-   each measurement by the agreement rule `harness::compare::vote` applies, and print per
-   font and per category the share of measurements that are unanimous, 2-1 and split, plus
-   the largest delta between engines. Raw responses go to `corpus/text-metrics/`, which is
-   gitignored, so a rerun can be compared.
-8. Write `docs/text-metrics.md` and append the one-paragraph entry to `roadmap.md`.
+The spec's own work is done. What remains is other tracks' business, recorded here
+because this measurement is what makes it decidable:
+
+1. Decide what, if anything, to do about the finding that a text-bearing generated
+   function cannot be scored against the geometry vote in a proportional font
+   (`docs/text-metrics.md` → "Verdict"). This spec was allowed to return a negative
+   result and did; acting on it is a new spec, not a continuation of this one.
+   *blocked on: a person deciding whether to commission that spec, and in what form.*
+2. If a later track wants the text probe on more shapes, the case corpus is the place to
+   extend: add a variant to `TextCategory` in `crates/harness/src/text_cases.rs` and a
+   recipe function beside the existing ones in `RECIPES`. The probe itself needs no
+   change for more Latin text in one writing mode; anything beyond that (bidi, vertical
+   writing modes, non-Latin shaping) is out of this spec's scope and was never measured.
 
 ## Decisions
 
+Taken while building, where the spec left a choice. Each is recorded with its reason.
+
+- **The proportional font is Lato (`fonts/Lato-Medium.ttf`), version 2.015, SIL Open Font
+  License 1.1.** The pinned checkout's `fonts/` holds several proportional Latin faces;
+  Lato is the one that is a TrueType file rather than WOFF (so real hinting is exercised,
+  not a compressed webfont path), carries kerning pairs for `AV` and `To`, and states its
+  own license in its name table, which is where the license above was read from rather
+  than assumed. The directory itself carries no license file.
+- **Every case names one family, `probe`, whichever font is being measured.** The oracle
+  binds that name to the requested font's bytes per request, so a category's markup is
+  byte-identical in its Ahem run and its Lato run and the only variable is the font file.
+  The alternative — a family name per font — would have made every case's CSS differ
+  between the two runs for no measured gain.
+- **The `@font-face` rule goes inside the document's `<head>`, not ahead of the string.**
+  The spec says "prepends"; a `<style>` before `<!doctype html>` makes the doctype content
+  and drops the page into quirks mode, which changes the geometry being measured. Inserting
+  after `<head>` keeps the rule self-contained under `page.setContent` and keeps standards
+  mode. Cases with no `<head>` still get it prepended, since there is no doctype to displace.
+- **The load gate is the `FontFace` status, with `document.fonts.check()` alongside it.**
+  The spec names `check()`; on its own it reports the system fallback as available for a
+  family with no matching face, so it answers "true" in exactly the case that has to fail.
+  Requiring a `probe` face to exist and every such face to report `loaded` is what actually
+  rules out a substituted font. Both are checked and either one failing fails the request.
+- **Each text node's data is truncated to 64 characters in the response.** Only the rects
+  are measured, and the probe's own document carries the font as a base64 `data:` URL —
+  roughly 850 KB for Lato — as one text node, which would otherwise dominate every stored
+  response in `corpus/text-metrics/`.
+- **The text vote lives in `crates/harness/src/trace.rs` (`vote_text`), not in
+  `compare.rs`.** `compare.rs` is not in this spec's `touches` list, and `compare::vote`
+  takes `Dump`s, which text-node rects are not. `vote_text` uses the public
+  `compare::Consensus` and `dump::TOLERANCE_PX`, and names `compare.rs` `classify()` as the
+  rule it applies. Element bounding boxes go through `compare::vote` unchanged, via
+  `TextDump::geometry()`.
+- **A text node that produced no line box in any engine is dropped from the tally.**
+  `<style>` contents are text nodes in document order and are reported as such, but counting
+  their unanimous "zero fragments" as agreement would inflate the headline figure with
+  measurements of geometry that does not exist.
+
 These are settled by the spec; do not reopen them.
 
 - Two fonts, measured separately. The first is Ahem (`fonts/Ahem.ttf` in the WPT checkout
@@ -79,52 +114,120 @@ These are settled by the spec; do not reopen them.
 - No generated function is built here, so the provisional rule for lifting hand-written
   logic into a generated function does not apply.
 
-## Key files & symbols
-
-- `oracle/oracle.mjs` — the new `textProbe` operation, beside `stackingProbe` and
-  `domDump`.
-- `oracle/selftest.mjs` — the new probe check.
-- `docs/dump-format.md` — the new "Text probe" section, in the form of "Stacking probe".
-- `crates/harness/src/dump.rs` — the request and response types, and `TOLERANCE_PX`.
-- `crates/harness/src/oracle.rs` — `Oracle::text_probe()`, shaped like
-  `Oracle::stacking_probe()`.
-- `crates/harness/src/text_cases.rs` — `Category` with `pub const ALL`, `Case`,
-  `enumerated()`, `random(seed, count)`; `cases::RESET` is reused from
-  `crates/harness/src/cases.rs`.
-- `crates/harness/src/bin/text_metrics.rs` — the measurement binary; it votes through
-  `harness::compare::vote`.
-- `crates/harness/src/lib.rs` — one `pub mod` line, additions only.
-- `docs/text-metrics.md` — the result.
-- `roadmap.md` → "Oracle expansion — in parallel with Phase 1" — one appended paragraph,
-  additions only.
-- `corpus/text-metrics/` — gitignored raw responses.
-- `oracle/suites/suites.json` — pins the WPT checkout the fonts come from.
-- `docs/geometry-verification.md` — the vote and its 1/60 px tolerance.
-
-## The result doc
-
-`docs/text-metrics.md` records the engines' versions (from `ping`), the fonts and their
-hashes, the per-category table for each font, which engine is the outlier where there is
-one, and a verdict per font. The verdict says whether a text-bearing generated function can
-be scored against a vote at 1/60 px, at a looser tolerance (and which), or not at all in
-that font.
+## Reference points
+
+What the built files are is listed under "Current state". These are the surrounding files
+they depend on or were modelled after, none of which this spec changed:
+
+- `oracle/suites/suites.json` — pins the WPT checkout (commit `26f417a8c0`) the fonts are
+  read from. Its `sparse` list already fetches `/fonts/`, so no change was needed there.
+- `crates/harness/src/compare.rs` — `vote()`, `Consensus` and `Metric`. Element boxes are
+  voted by it directly, and `trace.rs` `vote_text()` applies the same rule to text-node
+  rects, which are not `Dump` nodes. `compare.rs` is not in this spec's `touches` list and
+  was not modified.
+- `crates/harness/src/stacking_cases.rs` and `crates/harness/src/trace.rs`
+  `vote_stacking()` — the probe this one is shaped after, end to end.
+- `crates/harness/src/cases.rs` — `RESET`, reused verbatim by `text_cases.rs`; its `Elem`
+  and `document()` are not, because they render only empty `<div>`s.
+- `docs/geometry-verification.md` — the vote and its 1/60 px tolerance, which this
+  measurement is about.
+- `docs/platform-areas.md` → "Text and internationalization" — the row the verdict names.
+- `corpus/text-metrics/` — the raw per-engine responses, gitignored through the existing
+  `corpus/*` rule; no `.gitignore` change was needed.
+
+## The result
+
+`docs/text-metrics.md` carries it in full: engine versions, both fonts with their versions,
+licenses and sha256 hashes, a per-category and a per-quantity table for each font, the named
+outlier per quantity, what a looser tolerance would buy, and a verdict per font. In brief:
+
+- **Line breaking is unanimous.** All three engines produced the same number of line
+  fragments in 100% of measurements, in both fonts. Where a line starts and how tall it is
+  is contested; whether it starts is not.
+- **Element geometry of a text-bearing page is votable at 1/60 px**, 99–100% unanimous.
+  The text-free corpora were a simplification, not a necessity, as far as element boxes go.
+- **The text fragment's vertical extent is not votable in either font.** Firefox reports it
+  one pixel taller than Chromium and WebKit in over 90% of measurements.
+- **Ahem: a text-bearing generated function can be scored**, provided the reference is
+  allowed to come from a 2-1 majority, which `compare::vote` already permits. Fractional
+  font sizes must be avoided: Chromium rounds each glyph advance up to a whole pixel there,
+  which reached 7.5 px on a fifteen-glyph word at `13.5px`.
+- **Lato: it cannot.** Not one of the 104 `text fragment width` measurements was unanimous;
+  half were three-way splits with no reference value at all. Chromium rounds every run width
+  to a whole pixel, and Firefox and WebKit are themselves over a pixel apart on kerned text.
+- **A looser tolerance does not rescue it.** Fifteen times looser (0.25 px) buys nothing in
+  Ahem and 1.8 points in Lato; reaching 99% needs 1 px, sixty times the vote's tolerance, at
+  which the vote can no longer tell a correct box from one a whole pixel wrong.
 
 ## How to verify
 
-- `cargo test --workspace` passes, including unit tests in `crates/harness/src/text_cases.rs`
-  (every category enumerated, ids stable, every case names a pinned font) and in
-  `crates/harness/src/dump.rs` (a recorded `textProbe` response parses).
-- `node oracle/selftest.mjs --engines=chromium,firefox,webkit` passes.
-- `fragment_check --random` stays 227/227 and `bench/seam-floor.sh`'s floors hold. This
+- `bench/verify.sh` (the track gate: `cargo test --workspace`), including the unit tests in
+  `crates/harness/src/text_cases.rs` (every category enumerated, ids stable, every case
+  names the pinned font and no fallback), `crates/harness/src/dump.rs` (a recorded
+  `textProbe` response parses) and `crates/harness/src/trace.rs` (`vote_text`).
+- `node oracle/selftest.mjs --engines=chromium,firefox,webkit`.
+- `bench/fragment-floor.sh` stays at 227 and `bench/seam-floor.sh`'s floors hold. This
   spec changes no layout code, so any movement there is a bug in the oracle change.
+- Re-measuring: `cargo run --release -p harness --bin text_metrics -- --random 60 --seed
+  0x7e47` reproduces `docs/text-metrics.md`'s tables on the engine versions that document
+  names. Other engine versions will give other numbers; that is the point of recording the
+  versions and the font hashes.
+
+The build lane was unreachable for this work (`bench/on-lane.sh` reports "lane configured
+but unreachable" and falls back to a local run, which is its designed behaviour). Every
+result above was produced by that local fallback, on the same three Playwright browsers the
+lane would have used. Re-running on a reachable lane is worth doing if the numbers are ever
+disputed, though nothing here is timing-sensitive.
 
 ## Shared files
 
-`crates/harness/src/lib.rs` (one `pub mod` line) and `roadmap.md` (one appended paragraph)
-are shared with every spec that adds a generated function, and take additions only.
-`oracle/oracle.mjs` and `docs/dump-format.md` were last changed by `overflow-scrollbars`.
-The disabled `specs/dialog-popover-seam-cost.md` also names both, so the two must not run
-at once.
+Every shared file took additions only; nothing existing was changed or removed.
+
+- `crates/harness/src/lib.rs` — one `pub mod text_cases;` line.
+- `roadmap.md` — one appended entry under "Oracle expansion — in parallel with Phase 1".
+- `oracle/oracle.mjs` and `docs/dump-format.md` — last changed by `overflow-scrollbars`
+  before this. The disabled `specs/dialog-popover-seam-cost.md` also names both, so that
+  spec and this one must not run at once.
+- `crates/harness/src/trace.rs` — `vote_text()` and its types appended after
+  `vote_stacking()`; the stacking and trace votes are untouched.
+- `crates/harness/src/dump.rs` and `crates/harness/src/oracle.rs` — new types and one new
+  method; the existing `Request`, `Response`, `Dump` and every existing `Oracle` method are
+  unchanged, so `textProbe` is additive on the wire exactly as the spec required.
 
 ## Result
 
+**What now exists that did not.** A text probe in the oracle (`oracle/oracle.mjs`
+`textProbe`) that embeds one of two pinned WPT fonts as a `data:` URL, refuses to measure a
+page whose font fell back, and returns every text node's per-line-fragment rects alongside
+the ordinary element dump; its Rust client (`crates/harness/src/oracle.rs`
+`Oracle::text_probe()`) and wire types (`crates/harness/src/dump.rs`); a vote for those
+rects at the existing 1/60 px tolerance (`crates/harness/src/trace.rs` `vote_text()`); a
+ten-category text corpus (`crates/harness/src/text_cases.rs`); a measurement binary
+(`crates/harness/src/bin/text_metrics.rs`); documentation of the wire contract
+(`docs/dump-format.md` → "Text probe"); and the measured answer
+(`docs/text-metrics.md`), which the "Result" section above summarises. The spec is
+satisfied as written — every stage, gate and deliverable it names was built and run.
+
+**What the verify gate reports.** `bench/verify.sh` (`cargo test --workspace`) passes: 73
+test binaries, 0 failures, including the nine tests in `crates/harness/src/text_cases.rs`,
+the seven `vote_text` tests in `crates/harness/src/trace.rs`, and the two recorded-response
+tests in `crates/harness/src/dump.rs`. `node oracle/selftest.mjs
+--engines=chromium,firefox,webkit` passes 115/115 checks. `cargo clippy -p harness
+--all-targets` adds no new warning. `bench/fragment-floor.sh` reports 227/227 against a
+floor of 227, and `bench/seam-floor.sh` reports floats 109/109, stacking-order 105/105,
+relative-positioning 104/104 and block-height 105/105 — every floor met exactly, unmoved,
+as expected of a change that touches no layout code.
+
+**What a person has to decide.** Only one thing, and it is a new commission rather than
+unfinished work here: whether to act on the negative half of the result. Text geometry in a
+proportional font cannot be scored against a three-engine vote at 1/60 px, and no looser
+tolerance rescues it, so an oracle for shaping and glyph advances would have to be something
+other than a geometry vote. That is the first entry under "Next steps", labelled as blocked
+on that decision. Nothing else is outstanding.
+
+**One thing worth knowing about how these numbers were produced.** The build lane was
+unreachable throughout, so `bench/on-lane.sh` took its designed local fallback. The engines
+are the same three Playwright browsers either route would have used, and the figures are
+tied to their exact versions and to the fonts' sha256 hashes, both recorded in
+`docs/text-metrics.md`.
+
diff --git a/oracle/oracle.mjs b/oracle/oracle.mjs
index df7269b3..590859b5 100644
--- a/oracle/oracle.mjs
+++ b/oracle/oracle.mjs
@@ -6,6 +6,10 @@
 import { chromium, firefox, webkit } from 'playwright';
 import { createInterface } from 'node:readline';
 import { createServer } from 'node:http';
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 const ENGINE_LAUNCHERS = { chromium, firefox, webkit };
 const ALL_ENGINE_NAMES = Object.keys(ENGINE_LAUNCHERS);
@@ -61,6 +65,76 @@ const STYLE_PROPS = [
   'overflow-x', 'overflow-y',
 ];
 
+// Fonts the text probe can measure, by request key. Both are files in the WPT checkout
+// oracle/suites/suites.json pins (its sparse list already fetches /fonts/), so a
+// measurement is tied to exact bytes rather than to whatever the host happens to have
+// installed. Ahem's every glyph is a 1 em square; Lato is proportional, with real
+// advances, kerning pairs and hinting.
+const PROBE_FONTS = {
+  ahem: { file: 'Ahem.ttf', mime: 'font/ttf', format: 'truetype' },
+  lato: { file: 'Lato-Medium.ttf', mime: 'font/ttf', format: 'truetype' },
+};
+
+// Every text case names this one family and no fallback, whichever font key is measured,
+// so a category's markup is identical in both fonts and the only thing that varies is the
+// bytes behind the name. Nothing falls back silently: a face that did not load fails the
+// request rather than being measured against a substituted system font.
+const PROBE_FAMILY = 'probe';
+
+// How much of each text node's data a response keeps. Only the rects are measured, and a
+// text probe's document carries the font's base64 data: URL as one enormous text node.
+const MAX_TEXT_CHARS = 64;
+
+const ORACLE_DIR = dirname(fileURLToPath(import.meta.url));
+const WPT_FONTS_DIR = join(ORACLE_DIR, 'suites', 'checkouts', 'wpt', 'fonts');
+
+// key -> { sha256, css }. One read and one base64 encode per font per process; the CSS
+// text is reused for every request, which matters because Lato's data: URL is ~850 KB.
+const probeFontCache = new Map();
+
+async function loadProbeFont(key) {
+  const cached = probeFontCache.get(key);
+  if (cached) return cached;
+
+  const font = PROBE_FONTS[key];
+  if (!font) {
+    throw new Error(`unknown font key: ${key} (known: ${Object.keys(PROBE_FONTS).join(', ')})`);
+  }
+
+  const path = join(WPT_FONTS_DIR, font.file);
+  let bytes;
+  try {
+    bytes = await readFile(path);
+  } catch (err) {
+    throw new Error(
+      `font ${key} not found at ${path}: run \`node oracle/suites/fetch.mjs wpt\` to fetch the pinned checkout`,
+    );
+  }
+
+  const sha256 = createHash('sha256').update(bytes).digest('hex');
+  const css = `@font-face{font-family:"${PROBE_FAMILY}";`
+    + `src:url(data:${font.mime};base64,${bytes.toString('base64')}) format("${font.format}");`
+    + 'font-weight:normal;font-style:normal;font-display:block}';
+
+  const entry = { sha256, css };
+  probeFontCache.set(key, entry);
+  return entry;
+}
+
+// Puts the @font-face rule inside the document's own <head>, so the page stays
+// self-contained under page.setContent with no network fetch. Placing it there rather
+// than ahead of the string matters: a <style> before <!doctype html> would make the
+// doctype content and drop the page into quirks mode, which changes the geometry being
+// measured. A fragment with no <head> gets the rule prepended, which is safe because
+// there is no doctype to displace.
+function withFontFace(html, css) {
+  const style = `<style>${css}</style>`;
+  const head = /<head[^>]*>/i.exec(html);
+  if (!head) return style + html;
+  const at = head.index + head[0].length;
+  return html.slice(0, at) + style + html.slice(at);
+}
+
 function parseEngineList(argv) {
   const flag = argv.find((a) => a.startsWith('--engines='));
   if (!flag) return ALL_ENGINE_NAMES.slice();
@@ -378,6 +452,87 @@ function stackingDump({ points }) {
   };
 }
 
+// Runs in the page, for a text-probe request, before the geometry walk. Forces the probe
+// face to load, waits for font loading to settle, and reports what actually happened, so
+// the caller can refuse to measure a page that fell back to a system font. Kept
+// self-contained for the same reason domDump is.
+async function fontProbe({ family }) {
+  const spec = `16px "${family}"`;
+  try {
+    await document.fonts.load(spec);
+  } catch (err) {
+    // A load failure is reported through the face status below rather than thrown here,
+    // so the response says which family failed instead of only that something did.
+  }
+  await document.fonts.ready;
+
+  const faces = [];
+  document.fonts.forEach((face) => {
+    // Engines differ on whether FontFace.family keeps the source's quotes.
+    const name = face.family.replace(/^["']|["']$/g, '');
+    faces.push({ family: name, status: face.status });
+  });
+  const ours = faces.filter((f) => f.family === family);
+
+  return {
+    font_family: family,
+    font_faces: faces,
+    // True only when a face for this family exists in the document and every such face
+    // finished loading. `document.fonts.check` alone cannot carry this: for a family with
+    // no matching @font-face it reports the system fallback as available, so it answers
+    // "true" exactly in the case that must fail.
+    font_loaded: ours.length > 0 && ours.every((f) => f.status === 'loaded'),
+    fonts_check: document.fonts.check(spec),
+  };
+}
+
+// Runs in the page, for a text-probe request, after domDump. Reports every text node in
+// document order with its parent element's index and one rect per line fragment.
+//
+// The parent index is domDump's own node index. It is recomputed here rather than passed
+// in because the two walks are separate page.evaluate calls with no shared scope; what is
+// duplicated is only the ordering rule (pre-order from document.documentElement, children
+// in order), not the dump itself.
+//
+// `text` is truncated: the only measured quantities are the rects, and a text probe's
+// document carries the font's ~850 KB data: URL as a text node inside <style>, which
+// would otherwise dominate every stored response.
+function textDump({ maxTextChars }) {
+  const indexOf = new Map();
+  let next = 0;
+  (function visit(el) {
+    indexOf.set(el, next++);
+    for (const child of el.children) visit(child);
+  })(document.documentElement);
+
+  const texts = [];
+  const walker = document.createTreeWalker(document.documentElement, NodeFilter.SHOW_TEXT);
+  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+    const parent = indexOf.get(node.parentElement);
+    if (parent === undefined) continue;
+
+    const range = document.createRange();
+    range.selectNodeContents(node);
+    const rectList = range.getClientRects();
+    const rects = [];
+    for (let i = 0; i < rectList.length; i++) {
+      const r = rectList[i];
+      rects.push({ x: r.x, y: r.y, w: r.width, h: r.height });
+    }
+    range.detach();
+
+    const data = node.data;
+    texts.push({
+      parent,
+      text: data.length > maxTextChars ? data.slice(0, maxTextChars) : data,
+      truncated: data.length > maxTextChars,
+      rects,
+    });
+  }
+
+  return { texts };
+}
+
 // Renders the page served for one trace request. `html` is body markup, `script` is the
 // trace script text; both come from the request and are trusted the way the rest of the
 // oracle's html field is, so the only escaping done here is enough to keep the caller's
@@ -514,6 +669,32 @@ class Engine {
     return result;
   }
 
+  // Same serialization as run()/stackingProbe(), for a text-probe request: load html
+  // (with the @font-face rule already in its <head>), force the probe face to load and
+  // wait for font loading to settle, then take the ordinary element dump and the text
+  // walk. Three evaluate calls rather than one because domDump is reused as it stands
+  // instead of being copied into a text-specific variant.
+  textProbe(html, family) {
+    const result = this.queue.then(async () => {
+      await this.page.setContent(html, { waitUntil: 'load' });
+      const fonts = await this.page.evaluate(fontProbe, { family });
+      if (!fonts.font_loaded || !fonts.fonts_check) {
+        const seen = fonts.font_faces
+          .map((f) => `${f.family}=${f.status}`)
+          .join(', ') || 'no @font-face in the document';
+        throw new Error(
+          `probe font did not load: family "${family}" (faces: ${seen}; `
+          + `document.fonts.check=${fonts.fonts_check})`,
+        );
+      }
+      const dump = await this.page.evaluate(domDump, { viewport: VIEWPORT, styleProps: STYLE_PROPS });
+      const text = await this.page.evaluate(textDump, { maxTextChars: MAX_TEXT_CHARS });
+      return { ...dump, ...text, font_family: fonts.font_family };
+    });
+    this.queue = result.then(() => undefined, () => undefined);
+    return result;
+  }
+
   async close() {
     await this.browser.close();
   }
@@ -676,6 +857,41 @@ async function handleStackingRequest(req, engines) {
   return res;
 }
 
+async function handleTextRequest(req, engines) {
+  const names = requestedEngineNames(req, engines);
+  const results = {};
+  const errors = {};
+
+  // Read and hash the font once for the whole request: a missing checkout is a request
+  // failure, not a per-engine one, because no engine could have measured it.
+  const font = await loadProbeFont(req.font);
+  const html = withFontFace(req.html, font.css);
+
+  const unavailable = names.filter((name) => !engines.has(name));
+  for (const name of unavailable) errors[name] = 'engine not launched';
+  const live = names.filter((name) => engines.has(name));
+
+  await Promise.all(live.map(async (name) => {
+    const engine = engines.get(name);
+    try {
+      const dump = await engine.textProbe(html, PROBE_FAMILY);
+      results[name] = {
+        engine: name,
+        engine_version: engine.version,
+        font: req.font,
+        font_sha256: font.sha256,
+        ...dump,
+      };
+    } catch (err) {
+      errors[name] = String(err && err.message || err);
+    }
+  }));
+
+  const res = { id: req.id, results };
+  if (Object.keys(errors).length > 0) res.errors = errors;
+  return res;
+}
+
 async function handleLine(line, engines, onShutdown, server) {
   let req;
   try {
@@ -739,6 +955,20 @@ async function handleLine(line, engines, onShutdown, server) {
     }
   }
 
+  if (req.op === 'textProbe') {
+    if (typeof req.html !== 'string') {
+      return { id: req.id, error: 'textProbe request missing html' };
+    }
+    if (typeof req.font !== 'string') {
+      return { id: req.id, error: 'textProbe request missing font' };
+    }
+    try {
+      return await handleTextRequest(req, engines);
+    } catch (err) {
+      return { id: req.id, error: String(err && err.message || err) };
+    }
+  }
+
   if (typeof req.html !== 'string') {
     return { id: req.id, error: 'request missing html' };
   }
diff --git a/oracle/selftest.mjs b/oracle/selftest.mjs
index d9a0c865..8ebb5425 100644
--- a/oracle/selftest.mjs
+++ b/oracle/selftest.mjs
@@ -267,6 +267,72 @@ async function main() {
     );
   }
 
+  // textProbe: the probe answers with the ordinary element dump plus a per-text-node
+  // rect list, and the pinned font really loaded in every engine. Ahem is what makes the
+  // last part checkable rather than asserted: every one of its glyphs is a 1 em square,
+  // so two characters at 100px are exactly 200px wide and nothing else would be. A
+  // substituted fallback font -- the failure this probe exists to rule out -- cannot
+  // produce that number.
+  const textHtml = '<!doctype html><html><head><style>'
+    + 'html,body{margin:0;padding:0;border:0}'
+    + '.t{font-family:"probe";font-size:100px;line-height:1;width:400px}'
+    + '</style></head><body><div class="t">AA</div></body></html>';
+  const textRes = await oracle.send({ op: 'textProbe', html: textHtml, font: 'ahem', engines: active });
+  check(
+    'textProbe reports no per-engine error',
+    !textRes.errors || Object.keys(textRes.errors).length === 0,
+    JSON.stringify(textRes.errors),
+  );
+  for (const engine of active) {
+    const r = textRes.results && textRes.results[engine];
+    check(`${engine}: text probe answered`, !!r, JSON.stringify(textRes.errors));
+    if (!r) continue;
+
+    check(
+      `${engine}: text probe reports the font key and a sha256 of its bytes`,
+      r.font === 'ahem' && typeof r.font_sha256 === 'string' && /^[0-9a-f]{64}$/.test(r.font_sha256),
+      JSON.stringify({ font: r.font, font_sha256: r.font_sha256 }),
+    );
+    check(
+      `${engine}: text probe carries the element dump alongside the text nodes`,
+      Array.isArray(r.nodes) && r.nodes.length >= 4 && Array.isArray(r.texts),
+      JSON.stringify({ nodes: r.nodes && r.nodes.length, texts: r.texts && r.texts.length }),
+    );
+
+    const div = findNode(r, (n) => n.tag === 'DIV');
+    const aa = r.texts.find((t) => t.text === 'AA');
+    check(`${engine}: the text node is reported`, !!aa, JSON.stringify(r.texts.map((t) => t.text)));
+    if (!aa || !div) continue;
+
+    check(
+      `${engine}: the text node names its parent element's index`,
+      aa.parent === div.index,
+      JSON.stringify({ parent: aa.parent, div: div.index }),
+    );
+    check(
+      `${engine}: one line fragment, so one rect`,
+      aa.rects.length === 1,
+      JSON.stringify(aa.rects),
+    );
+    // The load gate is the oracle's own: a face that did not load fails the request, so
+    // reaching here at all means it loaded. This measures the loaded bytes to prove the
+    // gate is checking the right thing.
+    check(
+      `${engine}: the pinned Ahem loaded, not a fallback (2 glyphs at 100px = 200px)`,
+      Math.abs(aa.rects[0].w - 200) < 1 / 60,
+      JSON.stringify(aa.rects[0]),
+    );
+  }
+
+  // A font key with no file behind it is a request-level error naming the fetch command,
+  // not a silent measurement against something else.
+  const badFontRes = await oracle.send({ op: 'textProbe', html: textHtml, font: 'no-such-font', engines: active });
+  check(
+    'an unknown font key fails the request',
+    typeof badFontRes.error === 'string' && badFontRes.error.includes('no-such-font'),
+    JSON.stringify(badFontRes.error),
+  );
+
   await oracle.send({ op: 'shutdown' });
   oracle.stop();
 
diff --git a/roadmap.md b/roadmap.md
index 990e6a6a..916ee1b3 100644
--- a/roadmap.md
+++ b/roadmap.md
@@ -211,6 +211,14 @@ Oracles for what the geometry vote cannot see (`docs/oracle-coverage.md`):
   numeric execution (`docs/webgpu-cts.md`).
 - **Trace oracle** — script-observable behaviour voted across engines. Done for
   hand-written probes (`docs/dump-format.md` → "Trace protocol").
+- **Text metrics** — whether the three engines agree on text geometry closely enough for
+  the 1/60 px vote to run once glyphs are involved. Every other corpus here is text-free
+  by construction and the held-out WPT filter rejects any page with a text node, so this
+  had never been measured; until it was, no text-bearing generated function could be
+  scored. A text probe embeds a pinned font from the WPT checkout as a `data:` URL,
+  refuses to measure a page that fell back to a system font, and reports each text node's
+  line-fragment rects (`docs/dump-format.md` → "Text probe"). The result, per font and
+  per category, is `docs/text-metrics.md`.
 
 ### Phase 2 — Generation pipeline