diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1cc83c4..c634ce9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -187,6 +187,56 @@ A new profile field, `layout_unit_rule`, `line-units-v1` (the office profiles na
   twelve, sixteen and twenty-four and above a share of the unit's width; in the engine a gap of one
   line height between pieces scored above a half, seven tenths, one and a half and two.
 
+### A line read where the reading order reads it, and its words where the page set them apart (`line-units-v5`, decision #67)
+
+`layout_unit_rule` moves `line-units-v4` -> `line-units-v5`, so `profile_sha256` moves.
+
+- **A line is read where the reading order reads it.** On a page the reading order did not divide,
+  a line was every run on its baseline across the page, read where its first run was: a paragraph
+  whose baselines a byline or a caption in the next column shares was read where that column was,
+  and fell into several units (a ten-line newspaper paragraph read as five). Each line is now cut
+  into its pieces before any unit is read, and a line as the units read it is the pieces of one
+  line that follow each other in reading order.
+- **A word gap the page set by moving its pen reads as a space** where the rule reads a line's
+  text: wherever two runs' boxes stand a tenth of the line's height apart or more. A bullet set
+  apart by its position, with no space drawn after it, now opens a list item, and the hard-break
+  cut reads a line's first word as a word rather than as the whole line.
+- **Measured** on ParseBench: visual grounding 0.5435 -> 0.5575, 119 pages up and 8 down; content
+  one page up by 0.0003; tables, charts and formatting unchanged on every page; overall 46.42 ->
+  46.70. opendataloader-bench, the fabrication check and the gate documents' tables unchanged.
+- **The trade, taken by the owner**: the line spanning two columns gave each unit a far right edge,
+  and that edge cut some units by accident — a contents list's entries (`Marico_Annual_Report_FY24`
+  p4, twice in the set), a paragraph's last line, a label's — which now join; a bullet list the
+  ground truth keeps as one block (`entire-full-report-basf-ar24` p17) is a unit per bullet; and a
+  chart's labels join the text beside them, so its picture holds no text.
+
+### A line chart's printed values read as its table (`point-labels-v1`), and a panel's title names its numbers (`bar-labels-v3`), decision #66
+
+A new profile field, `table_detection.lines` = `point-labels-v1` (office profiles:
+`not-run-for-this-format`), and `table_detection.charts` `bar-labels-v2` -> `-v3`, so
+`profile_sha256` moves. `docs/32-CHART-LABELS-SCOPE.md` §8 and §9 are the rules.
+
+- **A line chart that prints a number at each point is a table**: a stroked line rising left to
+  right, or a run of three or more small marks of one colour, is a series; each number goes to the
+  one point it is set over, under or beside, unless another series' point stands nearly as near; a
+  year is never a value; a series keeps its numbers where six points in ten carry one and a higher
+  point never carries a smaller number; its categories are the first row of labels under the plot.
+  Series sharing that row are one table, each named by its legend swatch (a small mark or a short
+  stroke of its colour) or, alone, by the title over it. A value is never read off a point's
+  height.
+- **The interpreter carries the stroke colour** (`G`, `RG`, `K`, `SC`, `SCN`, reset by `CS`, saved
+  by `q`) and records each stroked subpath's points and each small filled mark with its colour;
+  only the line rule reads them.
+- **`bar-labels-v3`**: the title over a chart names the one series that prints numbers, whatever
+  else is drawn beside it — a progress bar's track no longer leaves its numbers unnamed.
+- **Measured** on ParseBench: charts 0.1184 -> 0.1248, 7 pages up and none down (`She-figures` p88
+  and `E-Government_Survey` p78 0 -> 1.0); tables, content, formatting and visual grounding
+  unchanged on every page; overall 46.29 -> 46.42. No line table on a table or text page; the gate
+  documents' tables unchanged.
+- **The trade, taken by the owner**: opendataloader-bench `01030000000078`'s line, read right
+  against its drawing, reorders that document's labels — its NID 0.8786 -> 0.8099 and TEDS 0.8667 ->
+  0.7086 (bench NID 0.8841 -> 0.8838, TEDS 0.5339 -> 0.5301), as decision #42's bar tables did.
+
 ### A heading's section number and its title are one line, and a label's lines one block (decision #65)
 
 Folded into `markdown-blocks-v12` and `html-blocks-v12`, which no release carries yet, so no rule id
diff --git a/crates/ethos-parser-cli/tests/public_api.rs b/crates/ethos-parser-cli/tests/public_api.rs
index 5672a68..54ab3ac 100644
--- a/crates/ethos-parser-cli/tests/public_api.rs
+++ b/crates/ethos-parser-cli/tests/public_api.rs
@@ -326,6 +326,7 @@ const CORE: &[&str] = &[
     "LAYOUT_UNIT_RULE_V2",
     "LAYOUT_UNIT_RULE_V3",
     "LAYOUT_UNIT_RULE_V4",
+    "LAYOUT_UNIT_RULE_V5",
     // Decision #41. The page-furniture rule id, and the edge a furniture run stands apart at.
     "FURNITURE_RULE_V1",
     "Furniture",
@@ -363,6 +364,9 @@ const CORE: &[&str] = &[
     "MARKDOWN_SCHEMA_VERSION",
     "TABLE_DETECTION_CHARTS_V1",
     "TABLE_DETECTION_CHARTS_V2",
+    // Decision #66.
+    "TABLE_DETECTION_CHARTS_V3",
+    "TABLE_DETECTION_LINES_V1",
     "TABLE_DETECTION_STROKE_V1",
     "TABLE_DETECTION_TAGGED_V1",
     "TABLE_DETECTION_TRACKS_V3",
diff --git a/crates/ethos-parser-core/src/lib.rs b/crates/ethos-parser-core/src/lib.rs
index b06f60f..8434290 100644
--- a/crates/ethos-parser-core/src/lib.rs
+++ b/crates/ethos-parser-core/src/lib.rs
@@ -125,23 +125,23 @@ pub use profile::{
     EPUB_READING_ORDER_RULE_V1, EPUB_TEXT_CODE_RULE_V2, FIGURE_RULE_V1, FORM_ANNOTATION_RULE_V2,
     FURNITURE_RULE_V1, HEADING_INFERENCE_RULE_V4, HEADING_INFERENCE_RULE_V5,
     HEADING_INFERENCE_RULE_V6, HEADING_INFERENCE_RULE_V7, LAYOUT_UNIT_RULE_V1, LAYOUT_UNIT_RULE_V2,
-    LAYOUT_UNIT_RULE_V3, LAYOUT_UNIT_RULE_V4, NOT_RUN, OBSERVATION_RULE_V3, OBSERVATION_RULE_V4,
-    ODP_READING_ORDER_RULE_V1, ODP_TEXT_CODE_RULE_V2, ODS_READING_ORDER_RULE_V1,
-    ODS_TEXT_CODE_RULE_V2, ODT_READING_ORDER_RULE_V1, ODT_TEXT_CODE_RULE_V2,
-    PPTX_READING_ORDER_RULE_V1, PPTX_TEXT_CODE_RULE_V3, READING_ORDER_RULE_V0,
-    READING_ORDER_RULE_V1, READING_ORDER_RULE_V2, READING_ORDER_RULE_V3, READING_ORDER_RULE_V4,
-    RIGHT_TO_LEFT_RULE_V1, RTF_READING_ORDER_RULE_V1, RTF_TEXT_CODE_RULE_V2, STRUCT_TREE_RULE_V1,
-    STRUCT_TREE_RULE_V2, TABLE_DETECTION_CHARTS_V1, TABLE_DETECTION_CHARTS_V2,
-    TABLE_DETECTION_STROKE_V1, TABLE_DETECTION_TAGGED_V1, TABLE_DETECTION_TRACKS_V10,
-    TABLE_DETECTION_TRACKS_V11, TABLE_DETECTION_TRACKS_V12, TABLE_DETECTION_TRACKS_V13,
-    TABLE_DETECTION_TRACKS_V14, TABLE_DETECTION_TRACKS_V3, TABLE_DETECTION_TRACKS_V4,
-    TABLE_DETECTION_TRACKS_V5, TABLE_DETECTION_TRACKS_V6, TABLE_DETECTION_TRACKS_V7,
-    TABLE_DETECTION_TRACKS_V8, TABLE_DETECTION_TRACKS_V9, TABLE_DETECTION_UNRULED_V1,
-    TABLE_DETECTION_V1, TABLE_DETECTION_V10, TABLE_DETECTION_V11, TABLE_DETECTION_V12,
-    TABLE_DETECTION_V2, TABLE_DETECTION_V3, TABLE_DETECTION_V4, TABLE_DETECTION_V5,
-    TABLE_DETECTION_V6, TABLE_DETECTION_V7, TABLE_DETECTION_V8, TABLE_DETECTION_V9,
-    TEXT_CODE_RULE_V2, TEXT_CODE_RULE_V3, TEXT_CODE_RULE_V4, XLSX_READING_ORDER_RULE_V1,
-    XLSX_TEXT_CODE_RULE_V3,
+    LAYOUT_UNIT_RULE_V3, LAYOUT_UNIT_RULE_V4, LAYOUT_UNIT_RULE_V5, NOT_RUN, OBSERVATION_RULE_V3,
+    OBSERVATION_RULE_V4, ODP_READING_ORDER_RULE_V1, ODP_TEXT_CODE_RULE_V2,
+    ODS_READING_ORDER_RULE_V1, ODS_TEXT_CODE_RULE_V2, ODT_READING_ORDER_RULE_V1,
+    ODT_TEXT_CODE_RULE_V2, PPTX_READING_ORDER_RULE_V1, PPTX_TEXT_CODE_RULE_V3,
+    READING_ORDER_RULE_V0, READING_ORDER_RULE_V1, READING_ORDER_RULE_V2, READING_ORDER_RULE_V3,
+    READING_ORDER_RULE_V4, RIGHT_TO_LEFT_RULE_V1, RTF_READING_ORDER_RULE_V1, RTF_TEXT_CODE_RULE_V2,
+    STRUCT_TREE_RULE_V1, STRUCT_TREE_RULE_V2, TABLE_DETECTION_CHARTS_V1, TABLE_DETECTION_CHARTS_V2,
+    TABLE_DETECTION_CHARTS_V3, TABLE_DETECTION_LINES_V1, TABLE_DETECTION_STROKE_V1,
+    TABLE_DETECTION_TAGGED_V1, TABLE_DETECTION_TRACKS_V10, TABLE_DETECTION_TRACKS_V11,
+    TABLE_DETECTION_TRACKS_V12, TABLE_DETECTION_TRACKS_V13, TABLE_DETECTION_TRACKS_V14,
+    TABLE_DETECTION_TRACKS_V3, TABLE_DETECTION_TRACKS_V4, TABLE_DETECTION_TRACKS_V5,
+    TABLE_DETECTION_TRACKS_V6, TABLE_DETECTION_TRACKS_V7, TABLE_DETECTION_TRACKS_V8,
+    TABLE_DETECTION_TRACKS_V9, TABLE_DETECTION_UNRULED_V1, TABLE_DETECTION_V1, TABLE_DETECTION_V10,
+    TABLE_DETECTION_V11, TABLE_DETECTION_V12, TABLE_DETECTION_V2, TABLE_DETECTION_V3,
+    TABLE_DETECTION_V4, TABLE_DETECTION_V5, TABLE_DETECTION_V6, TABLE_DETECTION_V7,
+    TABLE_DETECTION_V8, TABLE_DETECTION_V9, TEXT_CODE_RULE_V2, TEXT_CODE_RULE_V3,
+    TEXT_CODE_RULE_V4, XLSX_READING_ORDER_RULE_V1, XLSX_TEXT_CODE_RULE_V3,
 };
 pub use tables::{
     CellSlot, CheckStatus, GeometricFault, LocatorCheck, SlotCover, SlotFault, TableCellPosition,
diff --git a/crates/ethos-parser-core/src/profile.rs b/crates/ethos-parser-core/src/profile.rs
index c3a1424..f7dd4be 100644
--- a/crates/ethos-parser-core/src/profile.rs
+++ b/crates/ethos-parser-core/src/profile.rs
@@ -907,6 +907,30 @@ pub const TABLE_DETECTION_CHARTS_V1: &str = "bar-labels-v1";
 /// read. A value is still never read off a bar's length.
 pub const TABLE_DETECTION_CHARTS_V2: &str = "bar-labels-v2";
 
+/// [`TABLE_DETECTION_CHARTS_V2`] **with the title over a chart naming the one series that prints
+/// numbers** (decision #66, `docs/32-CHART-LABELS-SCOPE.md` §8).
+///
+/// `-v2` read a chart's title as its series' name only where the chart was drawn in one colour. A
+/// chart of bars drawn over a full-length track — a progress bar, one colour printing its numbers
+/// and one printing none — kept two series, and its one column of numbers went unnamed, though the
+/// panel's title above it names it. `-v3` reads the title for the one series that carries numbers,
+/// whatever else is drawn beside it.
+pub const TABLE_DETECTION_CHARTS_V3: &str = "bar-labels-v3";
+
+/// The rule that reads **the numbers a line chart prints at its points back as its table**
+/// (decision #66, `docs/32-CHART-LABELS-SCOPE.md` §9).
+///
+/// A series is a line a page stroked whose every point stands right of the one before, or a run
+/// of three or more small marks of one colour and size so set; each number on the page goes to the
+/// one point it stands over, under or beside, unless another series' point stands nearly as near.
+/// A series keeps its numbers where six points in ten carry one and a point higher on the page
+/// never carries a smaller number; its categories are the first row of labels below the plot with
+/// one label under each point; series sharing one row are one table, each named by the label
+/// beside a legend swatch of its colour, or a lone series by the title over it. A value is never
+/// read off a point's height. Runs after [`TABLE_DETECTION_CHARTS_V3`], on runs no other rule's
+/// table holds, only on a document that declares no author structure.
+pub const TABLE_DETECTION_LINES_V1: &str = "point-labels-v1";
+
 /// The structure-tree rule v1-S3 ships: read `/StructTreeRoot`, bind by `(page, mcid)`.
 ///
 /// On the profile because it changes output. Which structure types are recognised, how `/RoleMap`
@@ -1165,6 +1189,24 @@ pub const LAYOUT_UNIT_RULE_V3: &str = "line-units-v3";
 /// figure, opening where the figure opens, stays a line of its own. Units stay where, never what.
 pub const LAYOUT_UNIT_RULE_V4: &str = "line-units-v4";
 
+/// [`LAYOUT_UNIT_RULE_V4`] **with each line read where the reading order reads it, and its words
+/// where the page set them apart** (decision #67).
+///
+/// **What `-v4` missed.** Told "Grounding: text, round 2", the `Text` elements ParseBench's visual
+/// grounding could not place were read for why, and the largest share, 811 of them, lay split
+/// across several of our units. On a page the reading order did not divide, a line was every run
+/// on its baseline across the page, read where its first run was: a paragraph whose baselines a
+/// byline or a caption in the next column shares was read where that column was, and its lines
+/// fell into several units. And a page that sets its words by moving its pen draws no space
+/// between them, so a bullet set apart that way opened no list item, and the hard-break cut read a
+/// line's whole width as its first word.
+///
+/// **The change.** Each line is cut into its pieces before any unit is read, and a line as the
+/// units read it is the pieces of one line that follow each other in reading order. The text the
+/// list-marker clause and the first word are read from has a space wherever two runs' boxes stand
+/// a tenth of the line's height apart or more. Units stay where, never what.
+pub const LAYOUT_UNIT_RULE_V5: &str = "line-units-v5";
+
 /// The page-furniture rule decision #41 ships: **what a page sets apart at its top and bottom
 /// edges**.
 ///
@@ -1438,6 +1480,13 @@ pub struct TableDetection {
     /// See [`TABLE_DETECTION_CHARTS_V1`]. A sixth field for the reason there were five: its
     /// evidence — filled bars, their colours, and the labels set at them — is its own.
     pub charts: String,
+    /// Version id of the rule that reads the numbers a line chart prints at its points as its table
+    /// (decision #66).
+    ///
+    /// See [`TABLE_DETECTION_LINES_V1`]. A seventh field for the reason there were six: its
+    /// evidence — stroked lines and small marks, their colours, and the labels set at their points —
+    /// is its own.
+    pub lines: String,
 }
 
 impl Default for TableDetection {
@@ -1449,7 +1498,8 @@ impl Default for TableDetection {
             stroke_ruled: TABLE_DETECTION_STROKE_V1.to_string(),
             tagged: TABLE_DETECTION_TAGGED_V1.to_string(),
             tracks: TABLE_DETECTION_TRACKS_V14.to_string(),
-            charts: TABLE_DETECTION_CHARTS_V2.to_string(),
+            charts: TABLE_DETECTION_CHARTS_V3.to_string(),
+            lines: TABLE_DETECTION_LINES_V1.to_string(),
         }
     }
 }
@@ -2165,7 +2215,7 @@ pub struct Profile {
     pub heading_inference_rule: String,
     /// Version id of the layout-unit rule in force (decision #38).
     ///
-    /// See [`LAYOUT_UNIT_RULE_V4`]. Its own field for `heading_inference_rule`'s reason: it runs
+    /// See [`LAYOUT_UNIT_RULE_V5`]. Its own field for `heading_inference_rule`'s reason: it runs
     /// only where the document declares no structure, so folding it into a rule that runs on every
     /// document would make tagged artifacts non-comparable across a change to a rule that never
     /// ran on them. Refused, not defaulted, when absent.
@@ -2276,7 +2326,7 @@ impl Default for Profile {
             outline_rule: OUTLINE_RULE_V3.to_string(),
             text_box_rule: TEXT_BOX_RULE_V1.to_string(),
             heading_inference_rule: HEADING_INFERENCE_RULE_V7.to_string(),
-            layout_unit_rule: LAYOUT_UNIT_RULE_V4.to_string(),
+            layout_unit_rule: LAYOUT_UNIT_RULE_V5.to_string(),
             furniture_rule: FURNITURE_RULE_V1.to_string(),
             figure_rule: FIGURE_RULE_V1.to_string(),
             right_to_left_rule: RIGHT_TO_LEFT_RULE_V1.to_string(),
@@ -2366,6 +2416,7 @@ impl Profile {
                 tagged: NOT_RUN.into(),
                 tracks: NOT_RUN.into(),
                 charts: NOT_RUN.into(),
+                lines: NOT_RUN.into(),
             },
             reading_order_rule: DOCX_READING_ORDER_RULE_V2.to_string(),
             struct_tree_rule: NOT_RUN.into(),
@@ -2444,6 +2495,7 @@ impl Profile {
                 tagged: NOT_RUN.into(),
                 tracks: NOT_RUN.into(),
                 charts: NOT_RUN.into(),
+                lines: NOT_RUN.into(),
             },
             reading_order_rule: XLSX_READING_ORDER_RULE_V1.to_string(),
             struct_tree_rule: NOT_RUN.into(),
@@ -2516,6 +2568,7 @@ impl Profile {
                 tagged: NOT_RUN.into(),
                 tracks: NOT_RUN.into(),
                 charts: NOT_RUN.into(),
+                lines: NOT_RUN.into(),
             },
             reading_order_rule: PPTX_READING_ORDER_RULE_V1.to_string(),
             struct_tree_rule: NOT_RUN.into(),
@@ -2592,6 +2645,7 @@ impl Profile {
                 tagged: NOT_RUN.into(),
                 tracks: NOT_RUN.into(),
                 charts: NOT_RUN.into(),
+                lines: NOT_RUN.into(),
             },
             reading_order_rule: ODT_READING_ORDER_RULE_V1.to_string(),
             struct_tree_rule: NOT_RUN.into(),
@@ -2655,6 +2709,7 @@ impl Profile {
                 tagged: NOT_RUN.into(),
                 tracks: NOT_RUN.into(),
                 charts: NOT_RUN.into(),
+                lines: NOT_RUN.into(),
             },
             reading_order_rule: ODS_READING_ORDER_RULE_V1.to_string(),
             struct_tree_rule: NOT_RUN.into(),
@@ -2724,6 +2779,7 @@ impl Profile {
                 tagged: NOT_RUN.into(),
                 tracks: NOT_RUN.into(),
                 charts: NOT_RUN.into(),
+                lines: NOT_RUN.into(),
             },
             reading_order_rule: ODP_READING_ORDER_RULE_V1.to_string(),
             struct_tree_rule: NOT_RUN.into(),
@@ -2792,6 +2848,7 @@ impl Profile {
                 tagged: NOT_RUN.into(),
                 tracks: NOT_RUN.into(),
                 charts: NOT_RUN.into(),
+                lines: NOT_RUN.into(),
             },
             reading_order_rule: RTF_READING_ORDER_RULE_V1.to_string(),
             struct_tree_rule: NOT_RUN.into(),
@@ -2863,6 +2920,7 @@ impl Profile {
                 tagged: NOT_RUN.into(),
                 tracks: NOT_RUN.into(),
                 charts: NOT_RUN.into(),
+                lines: NOT_RUN.into(),
             },
             reading_order_rule: EPUB_READING_ORDER_RULE_V1.to_string(),
             struct_tree_rule: NOT_RUN.into(),
@@ -3052,6 +3110,7 @@ mod tests {
                 tagged,
                 tracks,
                 charts,
+                lines,
             })
         );
         assert_eq!(
@@ -3153,6 +3212,7 @@ mod tests {
                     tagged: _,
                     tracks: _,
                     charts: _,
+                    lines: _,
                 },
             struct_tree_rule: _,
             outline_rule: _,
@@ -3220,6 +3280,10 @@ mod tests {
                 "table_detection.charts",
                 Box::new(|p: &mut Profile| p.table_detection.charts = "other-charts-v9".into()),
             ),
+            (
+                "table_detection.lines",
+                Box::new(|p: &mut Profile| p.table_detection.lines = "other-lines-v9".into()),
+            ),
             (
                 // v1-S4. Which form and annotation nodes exist at all.
                 "form_annotation_rule",
@@ -3437,12 +3501,13 @@ mod tests {
         // `furniture_rule` the same way, and forty-two since decision #42, which added
         // `table_detection.charts` the same way. Forty-four since decision #46, which added
         // `figure_rule` and `capabilities.figures` the same way, and forty-five since decision
-        // #54, which added `right_to_left_rule` the same way.
+        // #54, which added `right_to_left_rule` the same way. Forty-six since decision #66, which
+        // added `table_detection.lines` the same way.
         assert_eq!(
             mutations.len(),
-            45,
-            "{} single-field mutation(s); forty-five is the number at decision #54, which added \
-             `right_to_left_rule` with its mutation",
+            46,
+            "{} single-field mutation(s); forty-six is the number at decision #66, which added \
+             `table_detection.lines` with its mutation",
             mutations.len()
         );
 
@@ -3497,7 +3562,7 @@ mod tests {
         let bytes = Profile::default().canonical_bytes().unwrap();
         assert_eq!(
             String::from_utf8(bytes).unwrap(),
-            r#"{"backend":{"components":{"flate2":"1.1.9","read-fonts":"0.36.0","skrifa":"0.39.0","unicode-bidi":"0.3.18"},"name":"lopdf","version":"0.44.0"},"capabilities":{"annotations":true,"char_offsets":true,"figures":true,"form_fields":true,"html":true,"images":true,"markdown":true,"measured_ink_boxes":true,"multi_column_reading_order":true,"outlines":true,"page_screenshots":false,"spans":true,"structural_locators":true,"tables":true},"classify_sample_pages":8,"cmap_data_version":"annex-d-encodings-4","coordinate_system":{"origin":"top-left","unit":"centipoint"},"figure_rule":"figure-regions-v1","font_metrics_data_version":"core14-afm-2","form_annotation_rule":"form-annotations-v2","furniture_rule":"margin-bands-v1","heading_inference_rule":"type-size-v7","html_rule":"html-blocks-v12","layout_unit_rule":"line-units-v4","locate_rule":"locate-scalar-exact-v1","markdown_rule":"markdown-blocks-v12","observation_rule":"page-observations-v4","outline_rule":"outlines-v3","page_budget":{"mode":"unlimited"},"parser_version":"0.64.0-dev.1","quantum_per_point":100,"raster_dpi":{"mode":"not_emitted"},"reading_order_rule":"gutter-columns-v4","right_to_left_rule":"right-to-left-lines-v1","struct_tree_rule":"struct-tree-v2","table_detection":{"charts":"bar-labels-v2","ruled":"ruled-rects-v12","stroke_ruled":"stroke-ruled-v1","tagged":"tagged-tables-v1","tracks":"whitespace-tracks-v14","unruled":"unruled-align-v1"},"text_box_rule":"advance-over-font-envelope-v1","text_code_rule":"declared-font-codes-v4","unicode_data_version":"std-unicode-16.0.0","verifier":{"mode":"not_pinned"},"xref_repair":{"mode":"pad-19-to-20-v1"}}"#,
+            r#"{"backend":{"components":{"flate2":"1.1.9","read-fonts":"0.36.0","skrifa":"0.39.0","unicode-bidi":"0.3.18"},"name":"lopdf","version":"0.44.0"},"capabilities":{"annotations":true,"char_offsets":true,"figures":true,"form_fields":true,"html":true,"images":true,"markdown":true,"measured_ink_boxes":true,"multi_column_reading_order":true,"outlines":true,"page_screenshots":false,"spans":true,"structural_locators":true,"tables":true},"classify_sample_pages":8,"cmap_data_version":"annex-d-encodings-4","coordinate_system":{"origin":"top-left","unit":"centipoint"},"figure_rule":"figure-regions-v1","font_metrics_data_version":"core14-afm-2","form_annotation_rule":"form-annotations-v2","furniture_rule":"margin-bands-v1","heading_inference_rule":"type-size-v7","html_rule":"html-blocks-v12","layout_unit_rule":"line-units-v5","locate_rule":"locate-scalar-exact-v1","markdown_rule":"markdown-blocks-v12","observation_rule":"page-observations-v4","outline_rule":"outlines-v3","page_budget":{"mode":"unlimited"},"parser_version":"0.64.0-dev.1","quantum_per_point":100,"raster_dpi":{"mode":"not_emitted"},"reading_order_rule":"gutter-columns-v4","right_to_left_rule":"right-to-left-lines-v1","struct_tree_rule":"struct-tree-v2","table_detection":{"charts":"bar-labels-v3","lines":"point-labels-v1","ruled":"ruled-rects-v12","stroke_ruled":"stroke-ruled-v1","tagged":"tagged-tables-v1","tracks":"whitespace-tracks-v14","unruled":"unruled-align-v1"},"text_box_rule":"advance-over-font-envelope-v1","text_code_rule":"declared-font-codes-v4","unicode_data_version":"std-unicode-16.0.0","verifier":{"mode":"not_pinned"},"xref_repair":{"mode":"pad-19-to-20-v1"}}"#,
             "the v0 profile changed. Expected causes: a crate version bump (parser_version is \
              part of identity, so a new build IS a new profile — that is by design), or a new \
              field. Update this vector and say why in the commit. Unexpected cause: something \
@@ -4634,11 +4699,19 @@ mod tests {
              set in. Nothing else.\n\n\
              Moved for decision #64, `sha256:dcfd6050…` -> `sha256:3e5e6b07…`: \
              `heading_inference_rule` `type-size-v6` -> `-v7`, which reads a run set a weight \
-             heavier than its page's body as bold. Nothing else."
+             heavier than its page's body as bold. Nothing else.\n\n\
+             Moved for decision #66, `sha256:3e5e6b07…` -> `sha256:3976f966…`: \
+             `table_detection.charts` `bar-labels-v2` -> `-v3`, which names the one series that \
+             prints numbers by the title over its chart, and the new `table_detection.lines`, \
+             `point-labels-v1`, which reads the numbers a line chart prints at its points back \
+             as its table. The office profiles name it `not-run-for-this-format`. Nothing else.\n\n\
+             Moved for decision #67, `sha256:3976f966…` -> `sha256:e0ffb37d…`: \
+             `layout_unit_rule` `line-units-v4` -> `-v5`, which reads each line where the reading \
+             order reads it and its words where the page set them apart. Nothing else."
         );
         assert_eq!(
             Profile::default().profile_sha256().unwrap().to_string(),
-            "sha256:3e5e6b071bcd48fe56258799c7a7e7b519579fdadd1049f7c4717182d11fd3aa"
+            "sha256:e0ffb37d1a2f8d95af4ac18a4eec88d651c4b0182bc7527858a38601b577b9e9"
         );
     }
 
@@ -4704,6 +4777,12 @@ mod tests {
             (TABLE_DETECTION_STROKE_V1, TABLE_DETECTION_CHARTS_V2),
             (TABLE_DETECTION_TAGGED_V1, TABLE_DETECTION_CHARTS_V2),
             (TABLE_DETECTION_TRACKS_V14, TABLE_DETECTION_CHARTS_V2),
+            (TABLE_DETECTION_V12, TABLE_DETECTION_LINES_V1),
+            (TABLE_DETECTION_UNRULED_V1, TABLE_DETECTION_LINES_V1),
+            (TABLE_DETECTION_STROKE_V1, TABLE_DETECTION_LINES_V1),
+            (TABLE_DETECTION_TAGGED_V1, TABLE_DETECTION_LINES_V1),
+            (TABLE_DETECTION_TRACKS_V14, TABLE_DETECTION_LINES_V1),
+            (TABLE_DETECTION_CHARTS_V3, TABLE_DETECTION_LINES_V1),
         ] {
             assert_ne!(
                 a, b,
@@ -4711,11 +4790,11 @@ mod tests {
             );
         }
 
-        // All six appear on the wire, under their own keys.
+        // All seven appear on the wire, under their own keys.
         let s = String::from_utf8(base.canonical_bytes().unwrap()).unwrap();
         assert!(
             s.contains(
-                r#""table_detection":{"charts":"bar-labels-v2","ruled":"ruled-rects-v12","stroke_ruled":"stroke-ruled-v1","tagged":"tagged-tables-v1","tracks":"whitespace-tracks-v14","unruled":"unruled-align-v1"}"#
+                r#""table_detection":{"charts":"bar-labels-v3","lines":"point-labels-v1","ruled":"ruled-rects-v12","stroke_ruled":"stroke-ruled-v1","tagged":"tagged-tables-v1","tracks":"whitespace-tracks-v14","unruled":"unruled-align-v1"}"#
             ),
             "{s}"
         );
@@ -4837,7 +4916,14 @@ mod tests {
             "a pre-#42 profile must not silently acquire the chart rule"
         );
 
-        let good = r#"{"ruled":"ruled-rects-v12","unruled":"unruled-align-v1","stroke_ruled":"stroke-ruled-v1","tagged":"tagged-tables-v1","tracks":"whitespace-tracks-v14","charts":"bar-labels-v2"}"#;
+        // And a profile from before decision #66 must not acquire the line rule.
+        let pre_lines = r#"{"ruled":"ruled-rects-v12","unruled":"unruled-align-v1","stroke_ruled":"stroke-ruled-v1","tagged":"tagged-tables-v1","tracks":"whitespace-tracks-v14","charts":"bar-labels-v3"}"#;
+        assert!(
+            serde_json::from_str::<TableDetection>(pre_lines).is_err(),
+            "a pre-#66 profile must not silently acquire the line rule"
+        );
+
+        let good = r#"{"ruled":"ruled-rects-v12","unruled":"unruled-align-v1","stroke_ruled":"stroke-ruled-v1","tagged":"tagged-tables-v1","tracks":"whitespace-tracks-v14","charts":"bar-labels-v3","lines":"point-labels-v1"}"#;
         assert_eq!(
             serde_json::from_str::<TableDetection>(good).unwrap(),
             TableDetection::default()
diff --git a/crates/ethos-parser-core/src/representation.rs b/crates/ethos-parser-core/src/representation.rs
index 227b05d..6130d07 100644
--- a/crates/ethos-parser-core/src/representation.rs
+++ b/crates/ethos-parser-core/src/representation.rs
@@ -1613,7 +1613,10 @@ pub struct TextRunAttributes {
     /// and value can be two units — and since `line-units-v3` before a body line whose first word
     /// would have fit twice over after the line above, so a contents list is a unit per entry. Since
     /// `line-units-v4` a script — a subscript, a superscript, a footnote mark, on a baseline of its
-    /// own — is part of the line it is set in.
+    /// own — is part of the line it is set in. Since `line-units-v5` a line is the pieces of one
+    /// baseline that follow each other in reading order, so a baseline running across columns the
+    /// reading order reads apart is a line per column, and its text has a space where its words
+    /// stand apart with none drawn, so a bullet set apart by its position opens a list item.
     ///
     /// **Where, never what**, as [`Self::block`] is: a unit says these lines read as one piece of
     /// text, not that the author wrote a paragraph, and no role is read from it. Absent on a
diff --git a/crates/ethos-parser-pdf/src/charts.rs b/crates/ethos-parser-pdf/src/charts.rs
index 2a39617..124d2f6 100644
--- a/crates/ethos-parser-pdf/src/charts.rs
+++ b/crates/ethos-parser-pdf/src/charts.rs
@@ -91,31 +91,31 @@ pub(crate) struct Bar {
 
 /// Runs joined along a baseline: what a chart prints as one label.
 #[derive(Debug)]
-struct Label {
+pub(crate) struct Label {
     /// Its inked runs left to right, then the spaces drawn between them.
-    runs: Vec<usize>,
-    x0: i64,
-    y0: i64,
-    x1: i64,
-    y1: i64,
+    pub(crate) runs: Vec<usize>,
+    pub(crate) x0: i64,
+    pub(crate) y0: i64,
+    pub(crate) x1: i64,
+    pub(crate) y1: i64,
     /// The line's height: the median height of its runs' boxes.
-    h: i64,
+    pub(crate) h: i64,
     /// The baseline.
-    base: i64,
+    pub(crate) base: i64,
     /// What it reads as: the runs' text, a space between two that stand apart with none drawn.
-    text: String,
+    pub(crate) text: String,
 }
 
 impl Label {
-    fn cx(&self) -> i64 {
+    pub(crate) fn cx(&self) -> i64 {
         (self.x0 + self.x1).div_euclid(2)
     }
 
-    fn cy(&self) -> i64 {
+    pub(crate) fn cy(&self) -> i64 {
         (self.y0 + self.y1).div_euclid(2)
     }
 
-    fn rect(&self) -> QuantRect {
+    pub(crate) fn rect(&self) -> QuantRect {
         QuantRect {
             x0: self.x0,
             y0: self.y0,
@@ -233,6 +233,18 @@ pub(crate) fn detect(
     Ok(tables)
 }
 
+/// The bars of every chart the rule finds on a page, whether or not it reads a table from them
+/// (`point-labels-v1`): a number set on a bar is the bar's, never a line's.
+pub(crate) fn chart_bars(bars: &[Bar], page_area: i128) -> Vec<QuantRect> {
+    let ink = ink(bars, page_area);
+    [Axis::Vertical, Axis::Horizontal]
+        .into_iter()
+        .flat_map(|axis| charts(&ink, axis))
+        .flat_map(|c| c.groups.into_iter().flatten().flat_map(|col| col.segs))
+        .map(|s| ink[s].rect)
+        .collect()
+}
+
 /// The labels a table reads: headers, categories, values.
 fn cells_of(f: &Found) -> Vec<usize> {
     let mut out: Vec<usize> = f.headers.iter().flatten().copied().collect();
@@ -245,7 +257,7 @@ fn cells_of(f: &Found) -> Vec<usize> {
 
 /// The page's labels: upright runs no other rule's table holds, by line, joined wherever less than
 /// half the line's height separates one run's ink from the next.
-fn labels(runs: &[TrackRun<'_>]) -> Vec<Label> {
+pub(crate) fn labels(runs: &[TrackRun<'_>]) -> Vec<Label> {
     let mut order: Vec<usize> = (0..runs.len())
         .filter(|&i| {
             !runs[i].claimed && !runs[i].text.trim().is_empty() && crate::tracks::upright(&runs[i])
@@ -865,20 +877,24 @@ fn table(
         .iter()
         .map(|&f| legend(f, chart, labels, ink, (bars, near), boxes, &used))
         .collect();
-    // A chart coloured by category takes no title: its colours key its categories, and the line
-    // above it is as often the section's heading (`-v2`).
-    if series.len() == 1 && headers[0].is_none() && !chart.by_category {
-        let top = rows
-            .iter()
-            .flat_map(|(_, v)| v.iter().flatten())
-            .map(|&k| labels[k].y0)
-            .fold(bars.y0, i64::min);
-        headers[0] = title(labels, QuantRect { y0: top, ..bars }, &used);
-    }
     // A series with no number printed in it is no column.
     let keep: Vec<usize> = (0..series.len())
         .filter(|&c| rows.iter().any(|(_, v)| v[c].is_some()))
         .collect();
+    // A chart coloured by category takes no title: its colours key its categories, and the line
+    // above it is as often the section's heading (`-v2`). `-v3`: the one series that carries
+    // numbers takes the title, whatever else is drawn beside it — a progress bar's track, a colour
+    // that prints none.
+    if let [only] = keep[..] {
+        if headers[only].is_none() && !chart.by_category {
+            let top = rows
+                .iter()
+                .flat_map(|(_, v)| v.iter().flatten())
+                .map(|&k| labels[k].y0)
+                .fold(bars.y0, i64::min);
+            headers[only] = title(labels, QuantRect { y0: top, ..bars }, &used);
+        }
+    }
     Some(Found {
         headers: keep.iter().map(|&c| headers[c]).collect(),
         rows: rows
@@ -1103,7 +1119,7 @@ fn wrapped_name(labels: &[Label], first: usize, ink: &[Bar]) -> Vec<usize> {
 /// The title of a chart of one colour: the block of lines nearest above it, within four lines,
 /// each the only label on its line over the chart and spanning its centre, ending in no full stop
 /// and holding no number but a year.
-fn title(labels: &[Label], chart: QuantRect, used: &[usize]) -> Option<usize> {
+pub(crate) fn title(labels: &[Label], chart: QuantRect, used: &[usize]) -> Option<usize> {
     let cx = (chart.x0 + chart.x1).div_euclid(2);
     let above: Vec<usize> = (0..labels.len())
         .filter(|&k| {
@@ -1151,7 +1167,7 @@ fn only_years(text: &str) -> bool {
 
 /// A number as charts print one, exactly.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-struct Value {
+pub(crate) struct Value {
     /// The digits, signed, with the decimals' digits after them.
     mantissa: i128,
     /// How many of them are decimals.
@@ -1176,7 +1192,7 @@ impl Ord for Value {
 /// `text` as a number: an optional sign or bracket, an optional currency sign, digits — grouped in
 /// threes by commas, or not at all — an optional decimal part, an optional unit (`%`, `x`, `k`,
 /// `m`, `bn`, `pp`) and an optional closing bracket. Anything else is not a number.
-fn number(text: &str) -> Option<Value> {
+pub(crate) fn number(text: &str) -> Option<Value> {
     let s: Vec<char> = text.chars().collect();
     let mut i = 0;
     let lead = s.first().copied().filter(|c| "(-−–+".contains(*c));
@@ -1239,7 +1255,7 @@ fn number(text: &str) -> Option<Value> {
 }
 
 /// A year: four digits, 19xx or 20xx.
-fn is_year(text: &str) -> bool {
+pub(crate) fn is_year(text: &str) -> bool {
     text.len() == 4
         && text.chars().all(|c| c.is_ascii_digit())
         && (text.starts_with("19") || text.starts_with("20"))
@@ -1280,6 +1296,34 @@ fn build(
     labels: &[Label],
     runs: &[TrackRun<'_>],
     alloc: &mut IdAllocator,
+) -> Result<DetectedTable, EngineError> {
+    let headers: Vec<Vec<usize>> = f
+        .headers
+        .iter()
+        .map(|h| h.iter().copied().collect())
+        .collect();
+    chart_table(
+        page,
+        &headers,
+        &f.rows,
+        labels,
+        runs,
+        alloc,
+        ethos_parser_core::TABLE_DETECTION_CHARTS_V3,
+    )
+}
+
+/// A chart's table from what it printed (`bar-labels-v1`, and `point-labels-v1`'s too): a header
+/// row of its series' names — each the labels of one name, or none — then a row per category, a
+/// cell for each label and none where nothing was printed.
+pub(crate) fn chart_table(
+    page: u32,
+    headers: &[Vec<usize>],
+    rows: &[(Vec<usize>, Vec<Option<usize>>)],
+    labels: &[Label],
+    runs: &[TrackRun<'_>],
+    alloc: &mut IdAllocator,
+    rule: &str,
 ) -> Result<DetectedTable, EngineError> {
     let id = alloc.next(IdKind::Table)?;
     let mut cells = Vec::new();
@@ -1313,12 +1357,12 @@ fn build(
             text,
         });
     };
-    for (c, h) in f.headers.iter().enumerate() {
-        if let Some(k) = h {
-            place(0, c + 1, &[*k]);
+    for (c, h) in headers.iter().enumerate() {
+        if !h.is_empty() {
+            place(0, c + 1, h);
         }
     }
-    for (r, (category, values)) in f.rows.iter().enumerate() {
+    for (r, (category, values)) in rows.iter().enumerate() {
         place(r + 1, 0, category);
         for (c, v) in values.iter().enumerate() {
             if let Some(k) = v {
@@ -1340,12 +1384,12 @@ fn build(
         id,
         page,
         rect,
-        rows: f.rows.len() as u32 + 1,
-        columns: f.headers.len() as u32 + 1,
+        rows: rows.len() as u32 + 1,
+        columns: headers.len() as u32 + 1,
         cells,
         check: not_a_lattice(),
         tagged_check: None,
-        rule: ethos_parser_core::TABLE_DETECTION_CHARTS_V2.to_string(),
+        rule: rule.to_string(),
     })
 }
 
@@ -1463,7 +1507,7 @@ mod tests {
             grid(&t[0]),
             vec!["|Solar", "2020|10", "2021|20", "2022|30", "2023|40"]
         );
-        assert_eq!(t[0].rule, ethos_parser_core::TABLE_DETECTION_CHARTS_V2);
+        assert_eq!(t[0].rule, ethos_parser_core::TABLE_DETECTION_CHARTS_V3);
         assert!(matches!(
             t[0].check.outcome,
             CheckStatus::NotApplicable { .. }
@@ -1765,6 +1809,38 @@ mod tests {
         assert_eq!(grid(&t[0]), vec!["|Yes|No", "Men|40|60", "Women|60|40"]);
     }
 
+    /// **A progress bar's one numbered series takes the title over it** (`bar-labels-v3`): each
+    /// value drawn over a track running on to the full length, only the values printing numbers,
+    /// the panel's title above — the track is no column, and the title names the one that is.
+    #[test]
+    fn a_progress_bar_s_numbers_take_the_title_over_it() {
+        let (value, track) = (rgb(0, 300, 800), rgb(850, 850, 850));
+        let mut bars = Vec::new();
+        let mut runs = vec![run(180, 92, 140, "Organizational framework")];
+        for (k, (cat, v)) in [("Portal", 95), ("Officer", 81), ("Links", 75)]
+            .into_iter()
+            .enumerate()
+        {
+            let y = 100 + 30 * k as i64;
+            let split = 100 + 3 * v;
+            bars.push(bar(100, y, split, y + 20, value));
+            bars.push(bar(split, y, 400, y + 20, track));
+            runs.push(run(140, y + 14, 16, ["95", "81", "75"][k]));
+            runs.push(run(40, y + 14, 50, cat));
+        }
+        let t = found(&runs, &bars);
+        assert_eq!(t.len(), 1, "{t:?}");
+        assert_eq!(
+            grid(&t[0]),
+            vec![
+                "|Organizational framework",
+                "Portal|95",
+                "Officer|81",
+                "Links|75"
+            ]
+        );
+    }
+
     #[test]
     fn a_table_s_shaded_cells_are_no_stack() {
         // Each value cell of each row shaded with a rectangle of its own, one grey, touching:
diff --git a/crates/ethos-parser-pdf/src/content.rs b/crates/ethos-parser-pdf/src/content.rs
index d3cab68..eb5b5bb 100644
--- a/crates/ethos-parser-pdf/src/content.rs
+++ b/crates/ethos-parser-pdf/src/content.rs
@@ -273,6 +273,16 @@ pub struct FilledRect {
     pub fill: Fill,
 }
 
+/// One line a page **stroked** (`point-labels-v1`): its points in order, in user space, and the
+/// colour it was stroked in.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Polyline {
+    /// Where each segment ends, the first point where the subpath began.
+    pub points: Vec<(f64, f64)>,
+    /// The stroke colour in force when it was painted.
+    pub stroke: Fill,
+}
+
 /// One open marked-content sequence (v1-S3).
 ///
 /// v0 tracked only the id, which was enough to copy an `/MCID` onto a run and not enough for
@@ -297,6 +307,9 @@ struct MarkedContent {
 struct Subpath {
     points: Vec<(f64, f64)>,
     disqualified: bool,
+    /// Every point the subpath reaches — where a line or a curve ends — for
+    /// [`Interpreter::polylines`] (`point-labels-v1`).
+    vertices: Vec<(f64, f64)>,
 }
 
 /// Interprets one page's content stream.
@@ -360,6 +373,16 @@ pub struct Interpreter<'a> {
     /// form's paths kept (`figure-regions-v1`, decision #46) — the figure rule's only input. A
     /// path ended with `n` painted nothing and is not here.
     pub painted: Vec<PathRect>,
+    /// The lines a stroke painted (`point-labels-v1`): each subpath's points in order — where a
+    /// curve ends, not its control points — in user space, with the stroke colour in force. A line
+    /// chart's series are such lines, and a legend's short strokes name them. Read by the line
+    /// rule alone.
+    pub polylines: Vec<Polyline>,
+    /// The small marks a fill painted (`point-labels-v1`): the box of each filled path a point to
+    /// fifteen points each way and near square — a dot, a diamond, a triangle, a small square —
+    /// with its fill colour. A line chart sets its points so, and a legend its swatches. Read by
+    /// the line rule alone.
+    pub marks: Vec<FilledRect>,
     /// The box of the path being built: every point and control point it has named so far.
     path_box: Option<PathRect>,
     /// Axis-aligned two-point stroked segments this page painted, in user space (v1-S8).
@@ -376,6 +399,8 @@ pub struct Interpreter<'a> {
     pending_filled: Vec<PathRect>,
     /// Segments from the current path, pending a painting operator (v1-S8).
     pending_segments: Vec<PathSegment>,
+    /// The current path's subpaths as lines, pending a painting operator (`point-labels-v1`).
+    pending_polylines: Vec<Vec<(f64, f64)>>,
     /// How many runs were dropped because a font could not map one of their codes.
     ///
     /// Separate from [`Interpreter::undecodable`]'s length: one run can carry several
@@ -460,6 +485,8 @@ impl<'a> Interpreter<'a> {
             white: Vec::new(),
             inset: Vec::new(),
             painted: Vec::new(),
+            polylines: Vec::new(),
+            marks: Vec::new(),
             path_box: None,
             filled: Vec::new(),
             filled_repeated: Vec::new(),
@@ -468,6 +495,7 @@ impl<'a> Interpreter<'a> {
             pending: Vec::new(),
             pending_filled: Vec::new(),
             pending_segments: Vec::new(),
+            pending_polylines: Vec::new(),
             dropped_runs: 0,
             fallback_runs: 0,
             props_by_name: 0,
@@ -556,6 +584,9 @@ impl<'a> Interpreter<'a> {
                 self.segments.clear();
                 self.pending.clear();
                 self.pending_filled.clear();
+                self.pending_polylines.clear();
+                self.polylines.clear();
+                self.marks.clear();
                 self.subpath = Subpath::default();
                 self.dropped_runs = 0;
                 Err(e)
@@ -622,6 +653,9 @@ impl<'a> Interpreter<'a> {
     /// else — an L, a triangle, a polyline, a curve — is discarded rather than approximated.
     fn flush_subpath(&mut self) {
         let sub = std::mem::take(&mut self.subpath);
+        if sub.vertices.len() >= 2 {
+            self.pending_polylines.push(sub.vertices.clone());
+        }
         if sub.disqualified || !self.ctm_is_axis_aligned() {
             return;
         }
@@ -808,8 +842,11 @@ impl<'a> Interpreter<'a> {
             // Line and colour state:
             LineWidth | LineCap | LineJoin | MiterLimit | DashPattern | RenderingIntent
             | Flatness | ExtGState => {}
-            StrokeColorSpace | StrokeColor | StrokeColorN | StrokeGray | StrokeRgb | StrokeCmyk => {
+            // `point-labels-v1`: the stroke colour, read as the fill colour is.
+            StrokeColor | StrokeColorN | StrokeGray | StrokeRgb | StrokeCmyk => {
+                self.gs.stroke = crate::text_state::Fill::of(operands)
             }
+            StrokeColorSpace => self.gs.stroke = crate::text_state::Fill::UNKNOWN,
             // Decision #42: the fill colour, which a chart's bars are told apart by. Operands that
             // are not numbers set a colour this reader does not know rather than stopping the parse:
             // a page that parsed before still parses. Naming a space resets the colour to one not
@@ -848,13 +885,17 @@ impl<'a> Interpreter<'a> {
                 if self.ctm_is_axis_aligned() {
                     self.pending.push(PathRect::from_corners(a, b));
                 }
-                self.subpath = Subpath::default();
+                let before = std::mem::take(&mut self.subpath);
+                if before.vertices.len() >= 2 {
+                    self.pending_polylines.push(before.vertices);
+                }
             }
             MoveTo => {
                 self.flush_subpath();
                 let p = self.gs.ctm.apply(num(operands, 0)?, num(operands, 1)?);
                 self.grow_path_box(p);
                 self.subpath.points.push(p);
+                self.subpath.vertices.push(p);
             }
             LineTo => {
                 let p = self.gs.ctm.apply(num(operands, 0)?, num(operands, 1)?);
@@ -867,6 +908,7 @@ impl<'a> Interpreter<'a> {
                     }
                 }
                 self.subpath.points.push(p);
+                self.subpath.vertices.push(p);
             }
             ClosePath => self.flush_subpath(),
             // **Curves are never tessellated into ruling lines.** Flattening a Bézier would
@@ -876,15 +918,19 @@ impl<'a> Interpreter<'a> {
             // The figure rule reads a curve's box from its points and control points, which hold
             // the curve: a Bézier lies inside the hull of its four.
             CurveTo | CurveToV | CurveToY => {
+                let mut end = None;
                 for i in (0..operands.len() / 2).map(|k| 2 * k) {
                     // Read where it can be, and skipped where it cannot: a curve was never
                     // refused for its operands before this rule read them.
                     if let (Ok(x), Ok(y)) = (num(operands, i), num(operands, i + 1)) {
                         let p = self.gs.ctm.apply(x, y);
                         self.grow_path_box(p);
+                        end = Some(p);
                     }
                 }
                 self.subpath.disqualified = true;
+                // `point-labels-v1`: where the curve ends is a point of the line it draws.
+                self.subpath.vertices.extend(end);
             }
 
             // --- painting: ink reached the page, so the pending rectangles are real ----------
@@ -898,8 +944,28 @@ impl<'a> Interpreter<'a> {
             | CloseFillStroke
             | CloseFillStrokeEvenOdd => {
                 self.flush_subpath();
+                let strokes = !matches!(op, Fill | FillObsolete | FillEvenOdd);
+                let fills = !matches!(op, Stroke | CloseStroke);
                 if let Some(b) = self.path_box.take() {
                     self.painted.push(b);
+                    // `point-labels-v1`: a small, near-square filled path is a mark.
+                    let (w, h) = (b.x1 - b.x0, b.y1 - b.y0);
+                    if fills
+                        && (1.0..=15.0).contains(&w)
+                        && (1.0..=15.0).contains(&h)
+                        && 20.0 * (w - h).abs() <= 7.0 * w.max(h)
+                    {
+                        self.marks.push(FilledRect {
+                            rect: b,
+                            fill: self.gs.fill,
+                        });
+                    }
+                }
+                let stroke = self.gs.stroke;
+                let lines = std::mem::take(&mut self.pending_polylines);
+                if strokes {
+                    self.polylines
+                        .extend(lines.into_iter().map(|points| Polyline { points, stroke }));
                 }
                 if matches!(op, Fill | FillObsolete | FillEvenOdd) {
                     let fill = self.gs.fill;
@@ -937,6 +1003,7 @@ impl<'a> Interpreter<'a> {
                 self.pending.clear();
                 self.pending_filled.clear();
                 self.pending_segments.clear();
+                self.pending_polylines.clear();
             }
             // A clip path bounds what is visible; it draws nothing. Treating one as a table edge
             // would find a grid in every document that clips to its margins.
@@ -945,6 +1012,7 @@ impl<'a> Interpreter<'a> {
                 self.pending.clear();
                 self.pending_filled.clear();
                 self.pending_segments.clear();
+                self.pending_polylines.clear();
             }
             // v1-S6. `Do` names an XObject in the page's resources. An `/Image` is a placement
             // this profile records; a `/Form` is content the page draws, run where the `Do`
@@ -1650,6 +1718,68 @@ mod tests {
         assert!(approx_eq(r.x1, 140.0) && approx_eq(r.y1, 120.0));
     }
 
+    /// **A stroked line carries its points and the stroke colour it was painted in**
+    /// (`point-labels-v1`): every point a line or a curve ends at, in user space; the colour `RG`
+    /// set, `Q` restoring the one `q` saved; nothing where the path was filled alone, ended with `n`
+    /// or made a clip.
+    #[test]
+    fn a_stroked_line_carries_its_points_and_its_stroke_colour() {
+        let fonts = no_fonts();
+        let mut i = Interpreter::new(&fonts);
+        i.run(&ops(
+            "0.2 0.4 0.6 RG 10 10 m 20 30 l 30 20 40 25 50 40 c S \
+             q 1 0 0 RG 0 0 m 5 5 l S Q 60 60 m 70 70 l S \
+             0 0 m 9 9 l f 0 0 m 9 9 l n 0 0 m 9 9 l W n",
+        ))
+        .unwrap();
+        let rgb = Fill {
+            components: [200, 400, 600, 0],
+            count: 3,
+        };
+        let red = Fill {
+            components: [1000, 0, 0, 0],
+            count: 3,
+        };
+        let lines: Vec<(Vec<(f64, f64)>, Fill)> = i
+            .polylines
+            .iter()
+            .map(|p| (p.points.clone(), p.stroke))
+            .collect();
+        assert_eq!(
+            lines,
+            vec![
+                (vec![(10.0, 10.0), (20.0, 30.0), (50.0, 40.0)], rgb),
+                (vec![(0.0, 0.0), (5.0, 5.0)], red),
+                (vec![(60.0, 60.0), (70.0, 70.0)], rgb),
+            ]
+        );
+    }
+
+    /// **A small filled shape near square is a mark** (`point-labels-v1`), with its fill colour —
+    /// a dot drawn with curves as a square one is — and a shape too large, too small, too long or
+    /// only stroked is none.
+    #[test]
+    fn a_small_filled_shape_is_a_mark() {
+        let fonts = no_fonts();
+        let mut i = Interpreter::new(&fonts);
+        i.run(&ops(
+            "0 0 1 rg 10 10 4 4 re f 20 20 m 24 20 l 24 24 l 20 24 l h f \
+             30 30 m 34 30 34 34 30 34 c f 40 40 16 16 re f 60 60 0.5 0.5 re f \
+             70 70 4 2 re f 80 80 4 4 re S",
+        ))
+        .unwrap();
+        let blue = Fill {
+            components: [0, 0, 1000, 0],
+            count: 3,
+        };
+        let marks: Vec<(i64, i64, Fill)> = i
+            .marks
+            .iter()
+            .map(|m| (m.rect.x0 as i64, m.rect.y0 as i64, m.fill))
+            .collect();
+        assert_eq!(marks, vec![(10, 10, blue), (20, 20, blue), (30, 30, blue)]);
+    }
+
     #[test]
     fn a_filled_rectangle_carries_the_fill_it_was_painted_in() {
         let fonts = no_fonts();
diff --git a/crates/ethos-parser-pdf/src/extract.rs b/crates/ethos-parser-pdf/src/extract.rs
index 687e2c2..b4b7630 100644
--- a/crates/ethos-parser-pdf/src/extract.rs
+++ b/crates/ethos-parser-pdf/src/extract.rs
@@ -1108,20 +1108,20 @@ fn extract_page(
         // Decision #42. Then a bar chart's printed labels, as its table
         // (`docs/32-CHART-LABELS-SCOPE.md`): on the runs no table above holds, under the tracks
         // rule's gate, and kept only where it overlaps no table already found.
-        if profile.table_detection.charts == ethos_parser_core::TABLE_DETECTION_CHARTS_V2
+        let mut bars = Vec::with_capacity(interp.filled.len() + interp.filled_repeated.len());
+        for f in interp.filled.iter().chain(&interp.filled_repeated) {
+            let (ax, ay) = geom.to_top_left(f.rect.x0, f.rect.y0);
+            let (bx, by) = geom.to_top_left(f.rect.x1, f.rect.y1);
+            bars.push(crate::charts::Bar {
+                rect: crate::tables::quantize_rect(ax, ay, bx, by)?,
+                fill: f.fill,
+            });
+        }
+        let q = f64::from(QUANTUM_PER_POINT);
+        let page_area = (geom.display_width * q) as i128 * (geom.display_height * q) as i128;
+        if profile.table_detection.charts == ethos_parser_core::TABLE_DETECTION_CHARTS_V3
             && no_author_structure(structure.as_ref())
         {
-            let mut bars = Vec::with_capacity(interp.filled.len() + interp.filled_repeated.len());
-            for f in interp.filled.iter().chain(&interp.filled_repeated) {
-                let (ax, ay) = geom.to_top_left(f.rect.x0, f.rect.y0);
-                let (bx, by) = geom.to_top_left(f.rect.x1, f.rect.y1);
-                bars.push(crate::charts::Bar {
-                    rect: crate::tables::quantize_rect(ax, ay, bx, by)?,
-                    fill: f.fill,
-                });
-            }
-            let q = f64::from(QUANTUM_PER_POINT);
-            let page_area = (geom.display_width * q) as i128 * (geom.display_height * q) as i128;
             let chart_runs = rule_runs(&runs, &ems, &ink_ends, &tables);
             for table in
                 crate::charts::detect(page_number, &chart_runs, &bars, page_area, &mut alloc)?
@@ -1132,6 +1132,50 @@ fn extract_page(
             }
         }
 
+        // Decision #66. Then the numbers a line chart prints at its points, as its table
+        // (`docs/32-CHART-LABELS-SCOPE.md` §9): on the runs no table above holds, under the tracks
+        // rule's gate, and kept only where it overlaps no table already found.
+        if profile.table_detection.lines == ethos_parser_core::TABLE_DETECTION_LINES_V1
+            && no_author_structure(structure.as_ref())
+        {
+            let mut strokes = Vec::with_capacity(interp.polylines.len());
+            for p in &interp.polylines {
+                let mut points = Vec::with_capacity(p.points.len());
+                for &(x, y) in &p.points {
+                    let (ax, ay) = geom.to_top_left(x, y);
+                    let r = crate::tables::quantize_rect(ax, ay, ax, ay)?;
+                    points.push((r.x0, r.y0));
+                }
+                strokes.push(crate::lines::Stroke {
+                    points,
+                    colour: p.stroke,
+                });
+            }
+            let mut marks = Vec::with_capacity(interp.marks.len());
+            for m in &interp.marks {
+                let (ax, ay) = geom.to_top_left(m.rect.x0, m.rect.y0);
+                let (bx, by) = geom.to_top_left(m.rect.x1, m.rect.y1);
+                marks.push(crate::lines::Mark {
+                    rect: crate::tables::quantize_rect(ax, ay, bx, by)?,
+                    colour: m.fill,
+                });
+            }
+            let chart_bars = crate::charts::chart_bars(&bars, page_area);
+            let line_runs = rule_runs(&runs, &ems, &ink_ends, &tables);
+            for table in crate::lines::detect(
+                page_number,
+                &line_runs,
+                &strokes,
+                &marks,
+                &chart_bars,
+                &mut alloc,
+            )? {
+                if !tables.iter().any(|t| t.rect.overlaps(table.rect)) {
+                    tables.push(table);
+                }
+            }
+        }
+
         // Decision #46. Last, once every table rule has run: the paths the page painted, read as
         // one drawing where they cluster (`docs/34-FIGURE-REGIONS-SCOPE.md`). Under the tracks
         // rule's gate, for its reason: a tagged document says what is a figure.
@@ -2214,7 +2258,7 @@ fn extract_counted(
     // Decision #38. Layout units, after headings — a heading line never shares a unit with body
     // text — and only where the document declares no author structure, whose own structure wins
     // there as it does for headings.
-    if profile.layout_unit_rule == ethos_parser_core::LAYOUT_UNIT_RULE_V4
+    if profile.layout_unit_rule == ethos_parser_core::LAYOUT_UNIT_RULE_V5
         && no_author_structure(structure.as_ref())
     {
         for page in pages.iter_mut() {
diff --git a/crates/ethos-parser-pdf/src/lib.rs b/crates/ethos-parser-pdf/src/lib.rs
index 5c79c17..b17ab8d 100644
--- a/crates/ethos-parser-pdf/src/lib.rs
+++ b/crates/ethos-parser-pdf/src/lib.rs
@@ -80,6 +80,7 @@ pub(crate) mod freed;
 mod furniture;
 pub(crate) mod headings;
 pub(crate) mod images;
+pub(crate) mod lines;
 pub(crate) mod magic;
 pub(crate) mod metrics;
 pub(crate) mod nodes;
diff --git a/crates/ethos-parser-pdf/src/lines.rs b/crates/ethos-parser-pdf/src/lines.rs
new file mode 100644
index 0000000..5a9cff1
--- /dev/null
+++ b/crates/ethos-parser-pdf/src/lines.rs
@@ -0,0 +1,919 @@
+//! A line chart's printed values, read back as its table — `point-labels-v1` (decision #66,
+//! `docs/32-CHART-LABELS-SCOPE.md` §9).
+//!
+//! A line chart that prints a number at each of its points states a table, as a bar chart that
+//! prints its numbers does (`crate::charts`), and this rule reads it the same way: a number is
+//! paired with the one point it is set at, a point with the one label under it at the foot of the
+//! plot, and a series with the legend swatch of its colour. A value is never read off a point's
+//! height: a point that carries no number leaves its cell empty, and a line that prints none yields
+//! no table.
+
+use ethos_parser_core::{EngineError, IdAllocator};
+
+use crate::charts::{chart_table, is_year, labels, number, title, Label, Value};
+use crate::tables::{DetectedTable, QuantRect};
+use crate::text_state::Fill;
+use crate::tracks::TrackRun;
+
+/// A line the page stroked, its points in the top-left system, centipoints.
+#[derive(Debug, Clone)]
+pub(crate) struct Stroke {
+    pub points: Vec<(i64, i64)>,
+    pub colour: Fill,
+}
+
+/// A small mark the page filled — a point of a line, or a legend's swatch — top-left, centipoints.
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct Mark {
+    pub rect: QuantRect,
+    pub colour: Fill,
+}
+
+/// A point of a series: its centre, and the half-width of what marks it.
+type Point = (i64, i64, i64);
+
+/// A series that reads: its index, its rows — each a category label and a value label — and the
+/// labels of the category row under it.
+type Reading = (usize, Vec<(usize, usize)>, Vec<usize>);
+
+/// The marks of one run: one colour, one width and one height, in half points.
+type MarkKey = (Fill, i64, i64);
+
+/// One series: its points left to right — each a centre and the half-width of what marks it — and
+/// its colour.
+#[derive(Debug)]
+struct Series {
+    points: Vec<Point>,
+    colour: Fill,
+}
+
+/// How far a point must stand right of the one before it, and how far one point of a line must
+/// stand above or below another, for the line to be a series: half a point.
+const STEP: i64 = 50;
+
+/// Two points are one where they stand within a point and a half of each other each way: a line
+/// drawn through its marks.
+const SAME_POINT: i64 = 150;
+
+/// A series keeps its numbers only where six points in ten carry one.
+const LABELLED_IN_TEN: usize = 6;
+
+/// A number nearly as near another series' point is neither's: within one and a half times its
+/// distance to its nearest, and a third of a point.
+const AMBIGUOUS: (i64, i64, i64) = (3, 2, 30);
+
+/// How many label lines below a plot its category row may stand.
+const CATEGORY_LINES: usize = 40;
+
+/// Past this many points on one page the rule reads nothing there: a map's or a drawing's lines,
+/// never a chart that prints a number at each point.
+const MAX_POINTS: usize = 200_000;
+
+/// Every table `point-labels-v1` finds on one page, in the order of its series.
+///
+/// `bars` are the bars of every chart `bar-labels-v3` found on the page: a number set on a bar is
+/// the bar's.
+///
+/// # Errors
+///
+/// An id the allocator cannot issue.
+pub(crate) fn detect(
+    page: u32,
+    runs: &[TrackRun<'_>],
+    strokes: &[Stroke],
+    marks: &[Mark],
+    bars: &[QuantRect],
+    alloc: &mut IdAllocator,
+) -> Result<Vec<DetectedTable>, EngineError> {
+    let labels = labels(runs);
+    let (series, swatches) = series(strokes, marks);
+    if series.iter().map(|s| s.points.len()).sum::<usize>() > MAX_POINTS {
+        return Ok(Vec::new());
+    }
+    let free: Vec<usize> = (0..labels.len())
+        .filter(|&k| !bars.iter().any(|b| covers(*b, &labels[k])))
+        .collect();
+    // A year names a time, as a category does, and is never a point's value: a timeline's dates
+    // set at its marks, or a year axis set along a line, read so would be a table of dates.
+    let numbers: Vec<usize> = free
+        .iter()
+        .copied()
+        .filter(|&k| number(&labels[k].text).is_some() && !is_year(&labels[k].text))
+        .collect();
+    let cells = assign(&series, &labels, &numbers);
+
+    // Each series that reads: its points' numbers, and the row of labels under them.
+    let mut read: Vec<Reading> = Vec::new();
+    for (si, s) in series.iter().enumerate() {
+        let mine: Vec<(usize, usize)> = cells
+            .iter()
+            .filter(|&&(cs, _, _)| cs == si)
+            .map(|&(_, p, k)| (p, k))
+            .collect();
+        let n = s.points.len();
+        if mine.len() < 2 || 10 * mine.len() < LABELLED_IN_TEN * n {
+            continue;
+        }
+        let values: Option<Vec<(usize, Value)>> = mine
+            .iter()
+            .map(|&(p, k)| number(&labels[k].text).map(|v| (p, v)))
+            .collect();
+        let Some(values) = values else { continue };
+        // The numbers agree with the drawing in order: a point clearly higher on the page carries a
+        // larger number.
+        let agrees = values.iter().all(|&(p, v)| {
+            let h = labels[mine.iter().find(|m| m.0 == p).map_or(0, |m| m.1)].h;
+            values
+                .iter()
+                .all(|&(q, w)| !(2 * s.points[p].1 < 2 * s.points[q].1 - h && v <= w))
+        });
+        if !agrees {
+            continue;
+        }
+        let pitch = pitch(&s.points);
+        let low = series
+            .iter()
+            .filter(|o| {
+                s.points
+                    .iter()
+                    .all(|p| o.points.iter().any(|q| 5 * (q.0 - p.0).abs() <= pitch))
+            })
+            .flat_map(|o| o.points.iter().map(|p| p.1 + p.2))
+            .max()
+            .unwrap_or(0);
+        let taken: Vec<usize> = mine.iter().map(|m| m.1).collect();
+        let pool: Vec<usize> = free
+            .iter()
+            .copied()
+            .filter(|k| !taken.contains(k))
+            .collect();
+        let Some(categories) = categories(&s.points, &labels, &pool, pitch, low) else {
+            continue;
+        };
+        let rows: Vec<(usize, usize)> = mine
+            .iter()
+            .filter_map(|&(p, k)| categories[p].map(|c| (c, k)))
+            .collect();
+        let mut texts: Vec<&str> = rows.iter().map(|&(c, _)| labels[c].text.as_str()).collect();
+        texts.sort_unstable();
+        texts.dedup();
+        if rows.len() < 2 || texts.len() != rows.len() {
+            continue;
+        }
+        let row_of: Vec<usize> = categories.iter().flatten().copied().collect();
+        read.push((si, rows, row_of));
+    }
+
+    // Series reading one row of categories are one table.
+    let mut groups: Vec<(Vec<usize>, Vec<usize>)> = Vec::new();
+    for (i, (_, _, row)) in read.iter().enumerate() {
+        let mut key = row.clone();
+        key.sort_unstable();
+        match groups.iter_mut().find(|g| g.0 == key) {
+            Some(g) => g.1.push(i),
+            None => groups.push((key, vec![i])),
+        }
+    }
+    let mut tables = Vec::new();
+    for (_, members) in groups {
+        let mut used: Vec<usize> = Vec::new();
+        let mut categories: Vec<(i64, usize)> = Vec::new();
+        for &m in &members {
+            let (si, rows, _) = &read[m];
+            for &(c, k) in rows {
+                used.push(k);
+                if !categories.iter().any(|&(_, o)| o == c) {
+                    let x = series[*si]
+                        .points
+                        .iter()
+                        .map(|p| p.0)
+                        .min_by_key(|x| (labels[c].cx() - x).abs())
+                        .unwrap_or(0);
+                    categories.push((x, c));
+                    used.push(c);
+                }
+            }
+        }
+        categories.sort_unstable();
+        let points = members.iter().flat_map(|&m| &series[read[m].0].points);
+        let plot = points.fold(None::<QuantRect>, |a, p| {
+            let r = QuantRect {
+                x0: p.0,
+                y0: p.1,
+                x1: p.0,
+                y1: p.1,
+            };
+            Some(a.map_or(r, |a| QuantRect {
+                x0: a.x0.min(r.x0),
+                y0: a.y0.min(r.y0),
+                x1: a.x1.max(r.x1),
+                y1: a.y1.max(r.y1),
+            }))
+        });
+        let Some(plot) = plot else { continue };
+        let mut headers: Vec<Vec<usize>> = Vec::new();
+        for &m in &members {
+            let name = legend(series[read[m].0].colour, &labels, &swatches, plot, &used)
+                .filter(|block| !headers.iter().any(|h| h.iter().any(|k| block.contains(k))))
+                .unwrap_or_default();
+            headers.push(name);
+        }
+        // A lone series with no legend takes the title over it, measured from its highest number as
+        // a bar chart's is.
+        if let [only] = &mut headers[..] {
+            if only.is_empty() {
+                let top = members
+                    .iter()
+                    .flat_map(|&m| read[m].1.iter().map(|r| labels[r.1].y0))
+                    .fold(plot.y0, i64::min);
+                only.extend(title(&labels, QuantRect { y0: top, ..plot }, &used));
+            }
+        }
+        let rows: Vec<(Vec<usize>, Vec<Option<usize>>)> = categories
+            .iter()
+            .map(|&(_, c)| {
+                let values = members
+                    .iter()
+                    .map(|&m| read[m].1.iter().find(|r| r.0 == c).map(|r| r.1))
+                    .collect();
+                (vec![c], values)
+            })
+            .collect();
+        tables.push(chart_table(
+            page,
+            &headers,
+            &rows,
+            &labels,
+            runs,
+            alloc,
+            ethos_parser_core::TABLE_DETECTION_LINES_V1,
+        )?);
+    }
+    Ok(tables)
+}
+
+/// Whether a bar covers a fifth of a label: a number set on a bar is the bar's.
+fn covers(bar: QuantRect, l: &Label) -> bool {
+    let w = l.x1.min(bar.x1) - l.x0.max(bar.x0);
+    let h = l.y1.min(bar.y1) - l.y0.max(bar.y0);
+    let area = i128::from(l.x1 - l.x0) * i128::from(l.y1 - l.y0);
+    w > 0 && h > 0 && 5 * i128::from(w) * i128::from(h) > area.max(1)
+}
+
+/// The median step between a series' points across the plot.
+fn pitch(points: &[Point]) -> i64 {
+    let mut steps: Vec<i64> = points.windows(2).map(|w| w[1].0 - w[0].0).collect();
+    steps.sort_unstable();
+    steps.get(steps.len() / 2).copied().unwrap_or(1).max(1)
+}
+
+/// The series on a page, and the swatches a legend may name them by.
+///
+/// A series is a stroked line of three points or more, each standing right of the one before it,
+/// not all at one height, or three marks or more of one colour and one size, each standing right of
+/// the one before. A line drawn over a series already read — through a run of marks, or the same
+/// line drawn twice — is that series; a run of marks all on a longer line is the line. A swatch is any small mark, or a short level
+/// stroke.
+fn series(strokes: &[Stroke], marks: &[Mark]) -> (Vec<Series>, Vec<Mark>) {
+    let mut swatches: Vec<Mark> = marks.to_vec();
+    let mut lines: Vec<&Stroke> = Vec::new();
+    for s in strokes {
+        if let [a, b] = s.points[..] {
+            let len = (b.0 - a.0).abs();
+            if (a.1 - b.1).abs() < 30 && (300..=4000).contains(&len) {
+                swatches.push(Mark {
+                    rect: QuantRect {
+                        x0: a.0.min(b.0),
+                        y0: a.1 - 50,
+                        x1: a.0.max(b.0),
+                        y1: a.1 + 50,
+                    },
+                    colour: s.colour,
+                });
+            }
+        }
+        let rising = s.points.windows(2).all(|w| w[1].0 - w[0].0 > STEP);
+        let level = s.points.windows(2).all(|w| (w[1].1 - w[0].1).abs() <= STEP);
+        if s.points.len() >= 3 && rising && !level {
+            lines.push(s);
+        }
+    }
+    let mut runs: Vec<(MarkKey, Vec<Point>)> = Vec::new();
+    for m in marks {
+        let (w, h) = (m.rect.x1 - m.rect.x0, m.rect.y1 - m.rect.y0);
+        let key = (m.colour, (w + 25).div_euclid(50), (h + 25).div_euclid(50));
+        let point = (
+            (m.rect.x0 + m.rect.x1).div_euclid(2),
+            (m.rect.y0 + m.rect.y1).div_euclid(2),
+            w.max(h).div_euclid(2),
+        );
+        match runs.iter_mut().find(|r| r.0 == key) {
+            Some(r) => r.1.push(point),
+            None => runs.push((key, vec![point])),
+        }
+    }
+    let mut out: Vec<Series> = Vec::new();
+    for (key, mut points) in runs {
+        points.sort_unstable();
+        points.dedup();
+        if key.0.count != 0
+            && points.len() >= 3
+            && points.windows(2).all(|w| w[1].0 - w[0].0 > STEP)
+        {
+            out.push(Series {
+                points,
+                colour: key.0,
+            });
+        }
+    }
+    for line in lines {
+        let points: Vec<Point> = line.points.iter().map(|&(x, y)| (x, y, 0)).collect();
+        if out
+            .iter()
+            .any(|o| 10 * on(&points, &o.points) >= 8 * points.len())
+        {
+            continue; // drawn over a series already read: its marks, or itself drawn twice
+        }
+        out.retain(|o| {
+            !(on(&o.points, &points) == o.points.len() && o.points.len() < points.len())
+        });
+        out.push(Series {
+            points,
+            colour: line.colour,
+        });
+    }
+    (out, swatches)
+}
+
+/// How many of `a`'s points stand on one of `b`'s.
+fn on(a: &[Point], b: &[Point]) -> usize {
+    a.iter()
+        .filter(|p| {
+            b.iter()
+                .any(|q| (p.0 - q.0).abs() <= SAME_POINT && (p.1 - q.1).abs() <= SAME_POINT)
+        })
+        .count()
+}
+
+/// How far label `l` stands from point `p` of a series `pitch` apart, in tenths of a centipoint, or
+/// `None` where it is not set at the point: centred over or under it within a line and a half, or
+/// beside it on its height within a line and a fifth.
+fn reach(l: &Label, p: Point, pitch: i64) -> Option<i64> {
+    let (x, y, r) = p;
+    let dx = (l.cx() - x).abs();
+    let half = (l.x1 - l.x0).div_euclid(2);
+    if 10 * dx <= 10 * half + 3 * l.h && 20 * dx <= 9 * pitch {
+        let over = y - r - l.y1;
+        if l.cy() < y && 10 * over >= -3 * l.h && 2 * over <= 3 * l.h {
+            return Some(10 * over.max(0) + dx);
+        }
+        let under = l.y0 - (y + r);
+        if l.cy() > y && 10 * under >= -3 * l.h && 2 * under <= 3 * l.h {
+            return Some(10 * under.max(0) + dx);
+        }
+    }
+    if 10 * (l.cy() - y).abs() <= 6 * l.h {
+        let right = l.x0 - (x + r);
+        if right >= 0 && 10 * right <= 12 * l.h {
+            return Some(10 * right);
+        }
+        let left = (x - r) - l.x1;
+        if left >= 0 && 10 * left <= 12 * l.h {
+            return Some(10 * left);
+        }
+    }
+    None
+}
+
+/// Each number to the one point it is set at, over every series of the page: its nearest, unless
+/// another series' point stands nearly as near; each point keeps its nearest number. As
+/// `(series, point, label)`.
+fn assign(series: &[Series], labels: &[Label], numbers: &[usize]) -> Vec<(usize, usize, usize)> {
+    let pitches: Vec<i64> = series.iter().map(|s| pitch(&s.points)).collect();
+    let mut best: Vec<((usize, usize), (i64, usize))> = Vec::new();
+    for &k in numbers {
+        let mut reached: Vec<(i64, usize, usize)> = Vec::new();
+        for (si, s) in series.iter().enumerate() {
+            for (pi, &p) in s.points.iter().enumerate() {
+                if let Some(d) = reach(&labels[k], p, pitches[si]) {
+                    reached.push((d, si, pi));
+                }
+            }
+        }
+        reached.sort_unstable();
+        let Some(&(d, si, pi)) = reached.first() else {
+            continue;
+        };
+        let (num, den, slack) = AMBIGUOUS;
+        if reached[1..]
+            .iter()
+            .any(|o| o.1 != si && den * o.0 <= num * d + den * 10 * slack)
+        {
+            continue;
+        }
+        match best.iter_mut().find(|b| b.0 == (si, pi)) {
+            Some(b) if d < b.1 .0 => b.1 = (d, k),
+            Some(_) => {}
+            None => best.push(((si, pi), (d, k))),
+        }
+    }
+    best.into_iter()
+        .map(|((si, pi), (_, k))| (si, pi, k))
+        .collect()
+}
+
+/// The labels naming a series' points: the first line of labels below the plot's lowest point —
+/// of the forty below it — holding one label under eight points in ten, no label twice and at most
+/// half of them numbers but years. Indexed by point.
+fn categories(
+    points: &[Point],
+    labels: &[Label],
+    pool: &[usize],
+    pitch: i64,
+    low: i64,
+) -> Option<Vec<Option<usize>>> {
+    let mut below: Vec<usize> = pool
+        .iter()
+        .copied()
+        .filter(|&k| labels[k].y0 >= low)
+        .collect();
+    below.sort_by_key(|&k| (labels[k].y0, labels[k].x0, k));
+    let mut lines: Vec<Vec<usize>> = Vec::new();
+    for k in below {
+        match lines.last_mut() {
+            Some(line) if 2 * (labels[k].y0 - labels[line[0]].y0) <= labels[k].h => line.push(k),
+            _ => lines.push(vec![k]),
+        }
+    }
+    for line in lines.iter().take(CATEGORY_LINES) {
+        let got: Vec<Option<usize>> = points
+            .iter()
+            .map(|p| {
+                let under: Vec<usize> = line
+                    .iter()
+                    .copied()
+                    .filter(|&k| 5 * (labels[k].cx() - p.0).abs() <= 2 * pitch)
+                    .collect();
+                if let [k] = under[..] {
+                    Some(k)
+                } else {
+                    None
+                }
+            })
+            .collect();
+        let found: Vec<usize> = got.iter().flatten().copied().collect();
+        let mut distinct = found.clone();
+        distinct.sort_unstable();
+        distinct.dedup();
+        let numeric = found
+            .iter()
+            .filter(|&&k| number(&labels[k].text).is_some() && !is_year(&labels[k].text))
+            .count();
+        if 10 * found.len() >= 8 * points.len()
+            && 2 * numeric <= found.len()
+            && distinct.len() == found.len()
+        {
+            return Some(got);
+        }
+    }
+    None
+}
+
+/// A series' name: beside the nearest swatch of its colour, the block of lines starting just right
+/// of it — the line that starts there and the lines of its left edge above and below it, each read
+/// up to the next swatch on its row — unless another name stands almost as near.
+fn legend(
+    colour: Fill,
+    labels: &[Label],
+    swatches: &[Mark],
+    plot: QuantRect,
+    used: &[usize],
+) -> Option<Vec<usize>> {
+    if colour.count == 0 {
+        return None;
+    }
+    let mut found: Vec<(i64, Vec<usize>, String)> = Vec::new();
+    for s in swatches.iter().filter(|s| s.colour == colour) {
+        let cy = (s.rect.y0 + s.rect.y1).div_euclid(2);
+        let first: Vec<usize> = (0..labels.len())
+            .filter(|&k| {
+                let l = &labels[k];
+                !used.contains(&k)
+                    && l.x0 >= s.rect.x1
+                    && l.x0 - s.rect.x1 <= 2 * l.h
+                    && 5 * (l.cy() - cy).abs() <= 8 * l.h
+            })
+            .collect();
+        let Some(&lead) = first.iter().min_by_key(|&&k| (labels[k].x0, k)) else {
+            continue;
+        };
+        let x0 = labels[lead].x0;
+        let stop = swatches
+            .iter()
+            .filter(|o| {
+                o.rect.x0 > s.rect.x1
+                    && ((o.rect.y0 + o.rect.y1).div_euclid(2) - cy).abs() <= 2 * labels[lead].h
+            })
+            .map(|o| o.rect.x0)
+            .min()
+            .unwrap_or(i64::MAX);
+        let mut starts: Vec<usize> = (0..labels.len())
+            .filter(|&k| {
+                let l = &labels[k];
+                2 * (l.x0 - x0).abs() <= l.h && 5 * (l.cy() - cy).abs() <= 11 * l.h
+            })
+            .collect();
+        starts.sort_by_key(|&k| (labels[k].y0, k));
+        let mut block: Vec<usize> = Vec::new();
+        let mut lines: Vec<String> = Vec::new();
+        for k in starts {
+            let l = &labels[k];
+            let mut row: Vec<usize> = (0..labels.len())
+                .filter(|&o| {
+                    let m = &labels[o];
+                    !used.contains(&o)
+                        && 10 * (m.base - l.base).abs() <= 3 * l.h
+                        && 2 * m.x0 >= 2 * x0 - l.h
+                        && m.x1 <= stop
+                })
+                .collect();
+            row.sort_by_key(|&o| (labels[o].x0, o));
+            let text = row
+                .iter()
+                .map(|&o| labels[o].text.as_str())
+                .collect::<Vec<_>>()
+                .join(" ");
+            if !text.is_empty() && !lines.contains(&text) {
+                lines.push(text);
+                for o in row {
+                    if !block.contains(&o) {
+                        block.push(o);
+                    }
+                }
+            }
+        }
+        let text = lines.join(" ");
+        if block.is_empty() || (number(&text).is_some() && !is_year(&text)) {
+            continue;
+        }
+        let (sx, sy) = ((s.rect.x0 + s.rect.x1).div_euclid(2), cy);
+        let dx = (plot.x0 - sx).max(0).max(sx - plot.x1);
+        let dy = (plot.y0 - sy).max(0).max(sy - plot.y1);
+        let d = (dx as f64).hypot(dy as f64) as i64;
+        if d > (plot.x1 - plot.x0).max(plot.y1 - plot.y0) {
+            continue;
+        }
+        found.push((d, block, text));
+    }
+    found.sort_by(|a, b| (a.0, &a.2).cmp(&(b.0, &b.2)));
+    let (d, block, name) = found.first()?;
+    if found
+        .iter()
+        .any(|(od, _, other)| other != name && *od < 2 * d + 500)
+    {
+        return None;
+    }
+    Some(block.clone())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ethos_parser_core::Profile;
+
+    fn alloc() -> IdAllocator {
+        IdAllocator::new(Profile::default().profile_sha256().expect("hashes"))
+    }
+
+    /// A 10pt label at `(x, y)` points — `y` its baseline — `w` points wide.
+    fn run(x: i64, y: i64, w: i64, text: &'static str) -> TrackRun<'static> {
+        let (x, y, w) = (x * 100, y * 100, w * 100);
+        TrackRun {
+            x,
+            y,
+            em: Some(1000),
+            rect: Some(QuantRect {
+                x0: x,
+                y0: y - 800,
+                x1: x + w,
+                y1: y + 200,
+            }),
+            text,
+            claimed: false,
+        }
+    }
+
+    fn rgb(r: i32, g: i32, b: i32) -> Fill {
+        Fill {
+            components: [r, g, b, 0],
+            count: 3,
+        }
+    }
+
+    /// A line through `(x, y)` points.
+    fn line(points: &[(i64, i64)], colour: Fill) -> Stroke {
+        Stroke {
+            points: points.iter().map(|&(x, y)| (x * 100, y * 100)).collect(),
+            colour,
+        }
+    }
+
+    /// Text of the cell at `(row, column)`.
+    fn cell(t: &DetectedTable, row: u32, column: u32) -> Option<String> {
+        t.cells
+            .iter()
+            .find(|c| c.position.row == row && c.position.column == column)
+            .map(|c| c.text.clone())
+    }
+
+    /// One line of five points rising left to right, a number over each, a year under each, and
+    /// a title over the chart.
+    fn one_line() -> (Vec<TrackRun<'static>>, Vec<Stroke>) {
+        let points = [(100, 300), (150, 280), (200, 260), (250, 240), (300, 220)];
+        let mut runs = vec![run(160, 195, 80, "Wages growth")];
+        for (i, &(x, y)) in points.iter().enumerate() {
+            runs.push(run(
+                x - 8,
+                y - 4,
+                16,
+                ["4.1", "4.5", "4.9", "5.3", "5.7"][i],
+            ));
+            runs.push(run(
+                x - 10,
+                340,
+                20,
+                ["2020", "2021", "2022", "2023", "2024"][i],
+            ));
+        }
+        (runs, vec![line(&points, rgb(0, 0, 900))])
+    }
+
+    /// **A line printing a number at each point is a table**: a row per category under the plot,
+    /// its numbers in one column named by the title over the chart.
+    #[test]
+    fn a_line_printing_its_numbers_is_a_table() {
+        let (runs, strokes) = one_line();
+        let t = detect(1, &runs, &strokes, &[], &[], &mut alloc()).expect("reads");
+        assert_eq!(t.len(), 1);
+        let t = &t[0];
+        assert_eq!(t.rule, ethos_parser_core::TABLE_DETECTION_LINES_V1);
+        assert_eq!((t.rows, t.columns), (6, 2));
+        assert_eq!(cell(t, 0, 1).as_deref(), Some("Wages growth"));
+        assert_eq!(cell(t, 1, 0).as_deref(), Some("2020"));
+        assert_eq!(cell(t, 1, 1).as_deref(), Some("4.1"));
+        assert_eq!(cell(t, 5, 1).as_deref(), Some("5.7"));
+    }
+
+    /// **The numbers must agree with the drawing**: a point higher on the page never carries a
+    /// smaller number, and six points in ten must carry one.
+    #[test]
+    fn numbers_that_disagree_with_the_drawing_or_leave_most_points_bare_are_no_table() {
+        let (mut runs, strokes) = one_line();
+        // The highest point's number made the smallest.
+        let k = runs.iter().position(|r| r.text == "5.7").expect("there");
+        runs[k].text = "1.0";
+        assert!(detect(1, &runs, &strokes, &[], &[], &mut alloc())
+            .expect("reads")
+            .is_empty());
+        // Three of five points bare.
+        let (runs, strokes) = one_line();
+        let runs: Vec<TrackRun<'static>> = runs
+            .into_iter()
+            .filter(|r| !["4.5", "4.9", "5.3"].contains(&r.text))
+            .collect();
+        assert!(detect(1, &runs, &strokes, &[], &[], &mut alloc())
+            .expect("reads")
+            .is_empty());
+    }
+
+    /// **Two lines sharing one row of categories are one table**, each named by the label beside a
+    /// legend stroke of its colour; a number standing nearly as near the other line's point is
+    /// neither's.
+    #[test]
+    fn two_lines_with_a_legend_are_one_table() {
+        let (blue, red) = (rgb(0, 0, 900), rgb(900, 0, 0));
+        let upper = [(100, 200), (150, 195), (200, 190), (250, 185), (300, 180)];
+        let lower = [(100, 300), (150, 290), (200, 280), (250, 270), (300, 260)];
+        let mut runs = Vec::new();
+        for i in 0..5 {
+            let (x, y) = upper[i];
+            runs.push(run(
+                x - 8,
+                y - 4,
+                16,
+                ["8.0", "8.2", "8.4", "8.6", "8.8"][i],
+            ));
+            let (x, y) = lower[i];
+            runs.push(run(
+                x - 8,
+                y + 14,
+                16,
+                ["2.0", "2.4", "2.8", "3.2", "3.6"][i],
+            ));
+            runs.push(run(
+                x - 10,
+                340,
+                20,
+                ["2020", "2021", "2022", "2023", "2024"][i],
+            ));
+        }
+        runs.push(run(125, 384, 40, "Imports"));
+        runs.push(run(225, 384, 40, "Exports"));
+        let strokes = vec![
+            line(&upper, blue),
+            line(&lower, red),
+            line(&[(100, 380), (120, 380)], blue),
+            line(&[(200, 380), (220, 380)], red),
+        ];
+        let t = detect(1, &runs, &strokes, &[], &[], &mut alloc()).expect("reads");
+        assert_eq!(t.len(), 1, "{t:?}");
+        let t = &t[0];
+        assert_eq!((t.rows, t.columns), (6, 3));
+        assert_eq!(cell(t, 0, 1).as_deref(), Some("Imports"));
+        assert_eq!(cell(t, 0, 2).as_deref(), Some("Exports"));
+        assert_eq!(cell(t, 3, 1).as_deref(), Some("8.4"));
+        assert_eq!(cell(t, 3, 2).as_deref(), Some("2.8"));
+        // A number set between the two lines' third points, nearly as near each, is neither's.
+        let mut between = runs.clone();
+        let k = between.iter().position(|r| r.text == "2.8").expect("there");
+        between[k] = run(192, 243, 16, "2.8");
+        let t = detect(1, &between, &strokes, &[], &[], &mut alloc()).expect("reads");
+        assert!(t.iter().all(|t| cell(t, 3, 2).is_none()), "{t:?}");
+    }
+
+    /// **A line drawn through its marks is one series**, and a run of marks reads as a line does.
+    #[test]
+    fn a_line_through_its_marks_is_one_series() {
+        let (runs, strokes) = one_line();
+        let marks: Vec<Mark> = strokes[0]
+            .points
+            .iter()
+            .map(|&(x, y)| Mark {
+                rect: QuantRect {
+                    x0: x - 200,
+                    y0: y - 200,
+                    x1: x + 200,
+                    y1: y + 200,
+                },
+                colour: rgb(0, 0, 900),
+            })
+            .collect();
+        let (s, _) = series(&strokes, &marks);
+        assert_eq!(s.len(), 1);
+        let t = detect(1, &runs, &[], &marks, &[], &mut alloc()).expect("reads");
+        assert_eq!(t.len(), 1);
+        assert_eq!(cell(&t[0], 3, 1).as_deref(), Some("4.9"));
+    }
+
+    /// **A year set at a point is no value**: a timeline's dates at its marks name times, as
+    /// categories do, and read as values they would be a table of dates.
+    #[test]
+    fn a_year_at_a_point_is_no_value() {
+        let (runs, strokes) = one_line();
+        let years = ["2007", "2010", "2013", "2016", "2019"];
+        let names = ["One", "Two", "Three", "Four", "Five"];
+        let runs: Vec<TrackRun<'static>> = runs
+            .into_iter()
+            .map(|mut r| {
+                if let Some(i) = ["4.1", "4.5", "4.9", "5.3", "5.7"]
+                    .iter()
+                    .position(|t| *t == r.text)
+                {
+                    r.text = years[i];
+                } else if let Some(i) = ["2020", "2021", "2022", "2023", "2024"]
+                    .iter()
+                    .position(|t| *t == r.text)
+                {
+                    r.text = names[i];
+                }
+                r
+            })
+            .collect();
+        assert!(detect(1, &runs, &strokes, &[], &[], &mut alloc())
+            .expect("reads")
+            .is_empty());
+    }
+
+    /// **A series rises left to right and is not level**: a line that turns back on itself — a
+    /// shape's outline — or one at a single height — a rule — is no series.
+    #[test]
+    fn a_line_that_turns_back_or_runs_level_is_no_series() {
+        let blue = rgb(0, 0, 900);
+        let back = line(&[(100, 300), (200, 250), (150, 200)], blue);
+        let level = line(&[(100, 300), (200, 300), (300, 300)], blue);
+        let rising = line(&[(100, 300), (200, 250), (300, 200)], blue);
+        let (s, _) = series(&[back, level, rising.clone()], &[]);
+        assert_eq!(s.len(), 1);
+        assert_eq!(s[0].points.len(), rising.points.len());
+    }
+
+    /// **A number set beside its point on its height is the point's**, as one over or under it
+    /// is.
+    #[test]
+    fn a_number_beside_its_point_is_read() {
+        let points = [(100, 300), (150, 280), (200, 260), (250, 240), (300, 220)];
+        let mut runs = vec![run(160, 195, 80, "Wages growth")];
+        for (i, &(x, y)) in points.iter().enumerate() {
+            runs.push(run(
+                x + 4,
+                y + 3,
+                16,
+                ["4.1", "4.5", "4.9", "5.3", "5.7"][i],
+            ));
+            runs.push(run(
+                x - 10,
+                340,
+                20,
+                ["2020", "2021", "2022", "2023", "2024"][i],
+            ));
+        }
+        let t = detect(
+            1,
+            &runs,
+            &[line(&points, rgb(0, 0, 900))],
+            &[],
+            &[],
+            &mut alloc(),
+        )
+        .expect("reads");
+        assert_eq!(t.len(), 1, "{t:?}");
+        assert_eq!(cell(&t[0], 2, 1).as_deref(), Some("4.5"));
+    }
+
+    /// **A line drawn twice is read once**, so its numbers are not torn between two copies of it;
+    /// and **a row of numbers under the plot is no category row**: the row of labels the
+    /// categories are read from holds at most half numbers but years.
+    #[test]
+    fn a_line_drawn_twice_is_read_once_and_numbers_name_no_category() {
+        let (mut runs, strokes) = one_line();
+        for (i, x) in [100, 150, 200, 250, 300].into_iter().enumerate() {
+            runs.push(run(x - 8, 320, 16, ["10", "20", "30", "40", "50"][i]));
+        }
+        let twice = [strokes.clone(), strokes].concat();
+        let t = detect(1, &runs, &twice, &[], &[], &mut alloc()).expect("reads");
+        assert_eq!(t.len(), 1, "{t:?}");
+        assert_eq!(cell(&t[0], 1, 0).as_deref(), Some("2020"));
+        assert_eq!(cell(&t[0], 1, 1).as_deref(), Some("4.1"));
+    }
+
+    /// **A number as near two lines' points is neither's**: set midway between them it stands
+    /// nearly as near each, and a series that kept it would be guessing.
+    #[test]
+    fn a_number_as_near_two_lines_is_neither_s() {
+        let upper = [(100, 195), (150, 192), (200, 190), (250, 187), (300, 185)];
+        let lower = [(100, 215), (150, 212), (200, 210), (250, 207), (300, 205)];
+        let mut runs = Vec::new();
+        for i in 0..5 {
+            runs.push(run(
+                upper[i].0 - 10,
+                340,
+                20,
+                ["2020", "2021", "2022", "2023", "2024"][i],
+            ));
+            if i == 2 {
+                continue;
+            }
+            let (x, y) = upper[i];
+            runs.push(run(
+                x - 8,
+                y - 4,
+                16,
+                ["8.0", "8.2", "8.4", "8.6", "8.8"][i],
+            ));
+            let (x, y) = lower[i];
+            runs.push(run(
+                x - 8,
+                y + 12,
+                16,
+                ["2.0", "2.4", "2.8", "3.2", "3.6"][i],
+            ));
+        }
+        // Midway between the third points: five points under the upper, five over the lower.
+        runs.push(run(192, 203, 16, "5.5"));
+        let strokes = vec![line(&upper, rgb(0, 0, 900)), line(&lower, rgb(900, 0, 0))];
+        let t = detect(1, &runs, &strokes, &[], &[], &mut alloc()).expect("reads");
+        assert_eq!(t.len(), 1, "{t:?}");
+        assert_eq!(cell(&t[0], 1, 1).as_deref(), Some("8.0"));
+        // The middle category carries no number in either series, so it is no row.
+        assert_eq!(t[0].rows, 5, "{t:?}");
+        assert!(t[0].cells.iter().all(|c| c.text != "5.5"), "{t:?}");
+    }
+
+    /// **A number set on a bar is the bar's**, never a line's.
+    #[test]
+    fn a_number_on_a_bar_is_no_line_value() {
+        let (runs, strokes) = one_line();
+        let bars: Vec<QuantRect> = [100, 150, 200, 250, 300]
+            .iter()
+            .map(|&x| QuantRect {
+                x0: (x - 12) * 100,
+                y0: 200 * 100,
+                x1: (x + 12) * 100,
+                y1: 330 * 100,
+            })
+            .collect();
+        assert!(detect(1, &runs, &strokes, &[], &bars, &mut alloc())
+            .expect("reads")
+            .is_empty());
+    }
+}
diff --git a/crates/ethos-parser-pdf/src/text_state.rs b/crates/ethos-parser-pdf/src/text_state.rs
index 40759f6..433f889 100644
--- a/crates/ethos-parser-pdf/src/text_state.rs
+++ b/crates/ethos-parser-pdf/src/text_state.rs
@@ -127,6 +127,9 @@ pub struct GraphicsState {
     pub ctm: Matrix,
     /// The colour the next fill paints in.
     pub fill: Fill,
+    /// The colour the next stroke paints in (`point-labels-v1`), set and compared as
+    /// [`Self::fill`] is: a line chart's series are told apart by it.
+    pub stroke: Fill,
 }
 
 impl Default for GraphicsState {
@@ -134,6 +137,7 @@ impl Default for GraphicsState {
         Self {
             ctm: Matrix::IDENTITY,
             fill: Fill::BLACK,
+            stroke: Fill::BLACK,
         }
     }
 }
diff --git a/crates/ethos-parser-pdf/src/units.rs b/crates/ethos-parser-pdf/src/units.rs
index 9e0af53..8d50933 100644
--- a/crates/ethos-parser-pdf/src/units.rs
+++ b/crates/ethos-parser-pdf/src/units.rs
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 //! **Layout units: lines joined by their own spacing** — decision #38's paragraph-like blocks,
-//! under `ethos_parser_core::LAYOUT_UNIT_RULE_V4`.
+//! under `ethos_parser_core::LAYOUT_UNIT_RULE_V5`.
 //!
 //! A page's lines — the runs sharing one band, one `/Artifact` state and one baseline, the heading
 //! rule's own unit — are read in reading order, and a line joins the unit above it when
@@ -49,6 +49,17 @@
 //! its start, is that line's. A smaller line stacked under a figure, opening where the figure
 //! opens, is a line of its own, as are two lines of one size.
 //!
+//! **And a line is read where the reading order reads it, its words where the page set them
+//! apart** (`line-units-v5`, [`lines_read`], [`spaced`]). On a page the reading order did not
+//! divide, a line was every run on its baseline across the page, read where its first run was: a
+//! paragraph whose baselines a byline or a caption in the next column shares was read where that
+//! column was, and fell into several units, each matching nothing. Each line is now cut into its
+//! pieces first, and a line as the units read it is the pieces of one line that follow each other
+//! in reading order. And the text the list-marker clause and the first word are read from has a
+//! space wherever two runs stand [`SPACE_GAP_TENTHS`] tenths of the line's height apart: a page that
+//! sets its words by moving its pen draws no space between them, so a bullet set apart that way
+//! opened no list item, and a line's first word was the whole line.
+//!
 //! **Where, never what.** A unit says these lines read as one piece of text; it is not the
 //! author's paragraph, and nothing reads a role from it — decision #19's rule for `region` and
 //! `block` holds here too. A table's runs and an `/Artifact`'s get no unit, nor does a line of
@@ -57,6 +68,7 @@
 //! heading clauses each added to it (`docs/measurements/parsebench/README.md`).
 
 use std::collections::{BTreeMap, BTreeSet};
+use std::ops::Range;
 
 use crate::nodes::PageExtract;
 
@@ -90,6 +102,12 @@ pub const HARD_BREAK_FIT: i64 = 2;
 /// line, and two lines of one size set in different faces differ by less than three twentieths.
 pub const SCRIPT_HEIGHT_TWENTIETHS: i64 = 17;
 
+/// Two runs of a line whose boxes stand this many tenths of the line's height apart, or more, have a
+/// space between them as the rule reads the line's text (`line-units-v5`): about a tenth of an em,
+/// well under the narrowest word space, a quarter of one, and over the kerning between two pieces
+/// of one word.
+pub const SPACE_GAP_TENTHS: i64 = 1;
+
 /// A line's box and baseline as the script join reads them: `x0, y0, x1, y1`, top-left system, and
 /// its first run's baseline, centipoints.
 pub(crate) type LineBox = (i64, i64, i64, i64, i64);
@@ -124,6 +142,42 @@ pub(crate) fn join_scripts(lines: Vec<Vec<usize>>, boxes: &[Option<LineBox>]) ->
     out.into_iter().map(|(line, _)| line).collect()
 }
 
+/// The lines the rule reads (`line-units-v5`): `of` holds, for each piece in reading order, the
+/// line it was cut from, and each line read is the range of the pieces of one line that follow each
+/// other there. A baseline the reading order reads in two places — a paragraph's line and a
+/// byline's beside it, in a column the reading order did not divide from it — is two lines, each
+/// read where it is read.
+pub(crate) fn lines_read(of: &[usize]) -> Vec<Range<usize>> {
+    let mut start = 0;
+    of.chunk_by(|a, b| a == b)
+        .map(|line| {
+            start += line.len();
+            start - line.len()..start
+        })
+        .collect()
+}
+
+/// A line's text as the rule reads it (`line-units-v5`): `runs` holds each run's text and, where it
+/// is inked and measured, its box's left and right edges, in the order they are read, and a space
+/// is read wherever a box opens [`SPACE_GAP_TENTHS`] tenths of `height` or more past where the box
+/// before it ended — a word gap the page set by moving its pen, and drew no space for.
+pub(crate) fn spaced(runs: &[(&str, Option<(i64, i64)>)], height: i64) -> String {
+    let mut text = String::new();
+    let mut end: Option<i64> = None;
+    for &(run, ink) in runs {
+        if let (Some(end), Some((x0, _))) = (end, ink) {
+            if height > 0 && 10 * (x0 - end) >= SPACE_GAP_TENTHS * height {
+                text.push(' ');
+            }
+        }
+        text.push_str(run);
+        if let Some((_, x1)) = ink {
+            end = Some(x1);
+        }
+    }
+    text
+}
+
 /// One line as the rule reads it.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) struct UnitLine {
@@ -355,64 +409,81 @@ pub(crate) fn assign(page: &mut PageExtract) {
         })
         .collect();
     let lines = join_scripts(lines, &boxes);
-    let read: Vec<UnitLine> = lines
+    let ink = |i: usize| {
+        let run = &page.runs[i];
+        (!run.text.trim().is_empty())
+            .then(|| run.geometry.measured())
+            .flatten()
+            .map(|b| (b.x0(), b.y0(), b.x1(), b.y1()))
+    };
+    let join = |a: Rect, b: Rect| (a.0.min(b.0), a.1.min(b.1), a.2.max(b.2), a.3.max(b.3));
+    // `-v5`: each line is cut into its pieces before any unit is read, each piece placed by its
+    // first run, and a line as the units read it is the pieces of one line that follow each other
+    // in reading order.
+    let mut cut: Vec<(usize, Option<Rect>, Vec<usize>)> = Vec::new();
+    for (l, line) in lines.iter().enumerate() {
+        let height = line
+            .iter()
+            .filter_map(|&i| ink(i))
+            .reduce(join)
+            .map_or(0, |r| r.3 - r.1);
+        let placed: Vec<(i64, Option<Rect>)> = line
+            .iter()
+            .map(|&i| (page.runs[i].locator.origin_x, ink(i)))
+            .collect();
+        for (rect, at) in pieces_of(&placed, height) {
+            cut.push((l, rect, at.iter().map(|&k| line[k]).collect()));
+        }
+    }
+    cut.sort_unstable_by_key(|(_, _, runs)| runs.iter().copied().min());
+    let read = lines_read(&cut.iter().map(|(l, _, _)| *l).collect::<Vec<_>>());
+    let text = |runs: &[usize], height: i64| {
+        let runs: Vec<(&str, Option<(i64, i64)>)> = runs
+            .iter()
+            .map(|&i| (page.runs[i].text.as_str(), ink(i).map(|b| (b.0, b.2))))
+            .collect();
+        spaced(&runs, height)
+    };
+    let unit_lines: Vec<UnitLine> = read
         .iter()
-        .map(|line| {
-            let inked: Vec<&crate::nodes::TextRun> = line
+        .map(|range| {
+            let members: BTreeSet<usize> = cut[range.clone()]
                 .iter()
-                .map(|&i| &page.runs[i])
-                .filter(|run| !run.text.trim().is_empty())
+                .flat_map(|(_, _, runs)| runs.iter().copied())
                 .collect();
-            let rect = inked
+            let line: Vec<usize> = lines[cut[range.start].0]
                 .iter()
-                .filter_map(|run| run.geometry.measured())
-                .map(|b| (b.x0(), b.y0(), b.x1(), b.y1()))
-                .reduce(|a, b| (a.0.min(b.0), a.1.min(b.1), a.2.max(b.2), a.3.max(b.3)));
-            let heading = inked
-                .first()
+                .copied()
+                .filter(|i| members.contains(i))
+                .collect();
+            let rect = line.iter().filter_map(|&i| ink(i)).reduce(join);
+            let heading = line
+                .iter()
+                .map(|&i| &page.runs[i])
+                .find(|run| !run.text.trim().is_empty())
                 .filter(|run| run.inferred_heading)
                 .map(|run| run.inferred_heading_level.unwrap_or(1));
-            let text: String = line.iter().map(|&i| page.runs[i].text.as_str()).collect();
             UnitLine {
                 rect,
                 heading,
-                marker: opens_with_marker(&text),
+                marker: opens_with_marker(&text(&line, rect.map_or(0, |r| r.3 - r.1))),
             }
         })
         .collect();
-    // Each piece with the runs it holds, ordered by its first run: reading order.
-    let mut placed_pieces: Vec<(usize, Piece, Vec<usize>)> = Vec::new();
-    for ((line, unit), read) in lines.iter().zip(units(&read)).zip(&read) {
-        let height = read.rect.map_or(0, |r| r.3 - r.1);
-        let placed: Vec<(i64, Option<Rect>)> = line
-            .iter()
-            .map(|&i| {
-                let run = &page.runs[i];
-                let b = (!run.text.trim().is_empty())
-                    .then(|| run.geometry.measured())
-                    .flatten()
-                    .map(|b| (b.x0(), b.y0(), b.x1(), b.y1()));
-                (run.locator.origin_x, b)
-            })
-            .collect();
-        for (rect, at) in pieces_of(&placed, height) {
-            let runs: Vec<usize> = at.iter().map(|&k| line[k]).collect();
-            let first = runs.iter().copied().min().unwrap_or(usize::MAX);
-            let text: String = runs.iter().map(|&i| page.runs[i].text.as_str()).collect();
-            let piece = Piece {
-                rect,
+    let mut pieces = Vec::with_capacity(cut.len());
+    for ((range, unit), line) in read.iter().zip(units(&unit_lines)).zip(&unit_lines) {
+        let height = line.rect.map_or(0, |r| r.3 - r.1);
+        for (_, rect, runs) in &cut[range.clone()] {
+            pieces.push(Piece {
+                rect: *rect,
                 unit,
-                first_word: rect.map_or(0, |r| first_word(&text, r.2 - r.0)),
-                heading: read.heading.is_some(),
-            };
-            placed_pieces.push((first, piece, runs));
+                first_word: rect.map_or(0, |r| first_word(&text(runs, height), r.2 - r.0)),
+                heading: line.heading.is_some(),
+            });
         }
     }
-    placed_pieces.sort_unstable_by_key(|(first, _, _)| *first);
-    let pieces: Vec<Piece> = placed_pieces.iter().map(|(_, piece, _)| *piece).collect();
-    let members: Vec<&Vec<usize>> = placed_pieces.iter().map(|(_, _, runs)| runs).collect();
     let short = cut_after_short_pieces(&pieces);
-    for (runs, unit) in members.into_iter().zip(cut_at_hard_breaks(&pieces, &short)) {
+    for ((_, _, runs), unit) in cut.iter().zip(cut_at_hard_breaks(&pieces, &short)) {
         for &i in runs {
             page.runs[i].layout_unit = Some(unit);
         }
@@ -749,4 +820,63 @@ mod tests {
             "an unmeasured line holds no script"
         );
     }
+
+    /// **A line is read where the reading order reads it** (`line-units-v5`): the pieces of one line
+    /// that follow each other in reading order are one line, and a line read in two places is two.
+    #[test]
+    fn a_line_read_in_two_places_is_two_lines() {
+        // A paragraph's last two baselines (lines 0 and 1) are a byline's too, beside it, and the
+        // byline is read first: each piece is a line of its own, read where it is read.
+        assert_eq!(lines_read(&[0, 1, 2, 0, 1]), [0..1, 1..2, 2..3, 3..4, 4..5]);
+        // A line's pieces read together stay one line.
+        assert_eq!(lines_read(&[0, 0, 1, 1, 1, 0]), [0..2, 2..5, 5..6]);
+        assert_eq!(lines_read(&[]), Vec::<Range<usize>>::new());
+        // So the byline is a unit and the paragraph another.
+        let lines = [
+            body(112, 400, 480),
+            body(124, 400, 480),
+            body(100, 72, 300),
+            body(112, 72, 300),
+            body(124, 72, 300),
+        ];
+        assert_eq!(units(&lines), [1, 1, 2, 2, 2]);
+    }
+
+    /// **A word gap the page set by moving its pen reads as a space** (`line-units-v5`): from a
+    /// tenth of the line's height, and not under it, so a bullet set apart by its position opens a
+    /// list item and a line's first word is a word, while two kerned pieces of a word stay one.
+    #[test]
+    fn a_gap_a_tenth_of_the_line_high_reads_as_a_space() {
+        // A line 1,000 high: a bullet 300 short of its item, then `ite` and `m` kerned 20 apart.
+        let item = [
+            ("•", Some((0, 400))),
+            ("First", Some((700, 2_000))),
+            ("ite", Some((2_300, 2_900))),
+            ("m", Some((2_920, 3_200))),
+        ];
+        assert_eq!(spaced(&item, 1_000), "• First item");
+        assert!(opens_with_marker(&spaced(&item, 1_000)));
+        assert!(!opens_with_marker("•Firstitem"), "as written, no marker");
+        // The boundary: a gap of a tenth is a space, a centipoint less is none.
+        assert_eq!(
+            spaced(&[("a", Some((0, 100))), ("b", Some((200, 300)))], 1_000),
+            "a b"
+        );
+        assert_eq!(
+            spaced(&[("a", Some((0, 100))), ("b", Some((199, 300)))], 1_000),
+            "ab"
+        );
+        // A run with no box reads as written and moves nothing; a line with no height reads none.
+        let drawn = [("a", Some((0, 100))), (" ", None), ("b", Some((150, 300)))];
+        assert_eq!(spaced(&drawn, 1_000), "a b");
+        assert_eq!(
+            spaced(&[("a", Some((0, 100))), ("b", Some((900, 1_000)))], 0),
+            "ab"
+        );
+        // `Cash flow` over 5,200: its first word and space are 2,888, where read as written,
+        // `Cashflow`, its first word was the whole line and a character more.
+        let entry = [("Cash", Some((0, 2_800))), ("flow", Some((3_100, 5_200)))];
+        assert_eq!(first_word(&spaced(&entry, 1_000), 5_200), 2_888);
+        assert_eq!(first_word("Cashflow", 5_200), 5_850);
+    }
 }
diff --git a/crates/ethos-parser-pdf/tests/extraction.rs b/crates/ethos-parser-pdf/tests/extraction.rs
index 29e4a46..5d40524 100644
--- a/crates/ethos-parser-pdf/tests/extraction.rs
+++ b/crates/ethos-parser-pdf/tests/extraction.rs
@@ -3713,6 +3713,147 @@ fn a_contents_list_is_cut_where_the_next_entry_would_have_fit() {
     );
 }
 
+/// One US Letter page drawing `content` in Helvetica at its own widths, WinAnsi-encoded, so `\225`
+/// is a bullet.
+fn helvetica_letter_page(content: &str) -> ExtractArtifact {
+    let objects: Vec<Vec<u8>> = vec![
+        b"<< /Type /Catalog /Pages 2 0 R >>".to_vec(),
+        b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_vec(),
+        b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] \
+           /Resources << /Font << /F1 5 0 R >> >> /Contents 4 0 R >>"
+            .to_vec(),
+        format!(
+            "<< /Length {} >>\nstream\n{content}\nendstream",
+            content.len()
+        )
+        .into_bytes(),
+        b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>"
+            .to_vec(),
+    ];
+    let profile = Profile::default();
+    let d = Document::open_bytes(&pdf_from_objects(&objects), &profile).expect("opens");
+    ethos_parser_pdf::extract(&d, &profile).expect("extracts")
+}
+
+/// **A line is read where the reading order reads it, and its words where the page set them
+/// apart** (`line-units-v5`), end to end, on four pages the reading order does not divide.
+///
+/// A paragraph whose last two baselines a byline beside it shares, the byline drawn first, is one
+/// unit: read where the byline was, it fell in two. Beside a bulleted aside drawn before it, the
+/// paragraph is still one unit and each bullet opens an item: read with its baseline's runs, each
+/// of its lines opened with the aside's bullet. Bullets set apart by their position, with no
+/// space drawn after them, each open an item. And a contents list whose words are set by moving the
+/// pen is cut before `Cash`, whose first word fits twice over after the entry above once it is read
+/// as a word — read as the whole line, it never fit.
+#[test]
+fn a_line_is_read_where_the_reading_order_reads_it_and_its_words_where_they_stand() {
+    let units = |content: &str| -> Vec<(String, u32)> {
+        let a = helvetica_letter_page(content);
+        let inked: Vec<&TextRun> = runs(&a)
+            .into_iter()
+            .filter(|r| !r.text.trim().is_empty())
+            .collect();
+        assert!(
+            inked.iter().all(|r| r.region.is_none()),
+            "the reading order divides none of these pages"
+        );
+        inked
+            .iter()
+            .map(|r| {
+                (
+                    r.text.clone(),
+                    r.layout_unit.expect("every line has a unit"),
+                )
+            })
+            .collect()
+    };
+    let of = |units: &[(String, u32)]| units.iter().map(|(_, u)| *u).collect::<Vec<_>>();
+
+    // A title across the whole page leaves no gutter for the reading order to divide it at.
+    let byline = units(
+        "BT /F1 12 Tf 1 0 0 1 72 740 Tm \
+         (A title set across the whole width of the page, over both of its columns) Tj ET\n\
+         BT /F1 12 Tf 1 0 0 1 400 686 Tm (BY A WRITER) Tj ET\n\
+         BT /F1 12 Tf 1 0 0 1 400 672 Tm (AND ANOTHER) Tj ET\n\
+         BT /F1 12 Tf 1 0 0 1 72 700 Tm (The first line of a paragraph set across) Tj ET\n\
+         BT /F1 12 Tf 1 0 0 1 72 686 Tm (the measure of its column, and its second) Tj ET\n\
+         BT /F1 12 Tf 1 0 0 1 72 672 Tm (line, and a third one ending the paragraph.) Tj ET",
+    );
+    assert_eq!(of(&byline), [1, 2, 2, 3, 3, 3], "{byline:?}");
+    let aside = units(
+        "BT /F1 12 Tf 1 0 0 1 72 740 Tm \
+         (A title set across the whole width of the page, over both of its columns) Tj ET\n\
+         BT /F1 12 Tf 1 0 0 1 400 686 Tm (\\225) Tj ET\n\
+         BT /F1 12 Tf 1 0 0 1 414 686 Tm (A point aside) Tj ET\n\
+         BT /F1 12 Tf 1 0 0 1 400 672 Tm (\\225) Tj ET\n\
+         BT /F1 12 Tf 1 0 0 1 414 672 Tm (Another point) Tj ET\n\
+         BT /F1 12 Tf 1 0 0 1 72 700 Tm (The first line of a paragraph set across) Tj ET\n\
+         BT /F1 12 Tf 1 0 0 1 72 686 Tm (the measure of its column, and its second) Tj ET\n\
+         BT /F1 12 Tf 1 0 0 1 72 672 Tm (line, and a third one ending the paragraph.) Tj ET",
+    );
+    assert_eq!(of(&aside), [1, 2, 2, 3, 3, 4, 4, 4], "{aside:?}");
+
+    let mut list = String::from(
+        "BT /F1 12 Tf 1 0 0 1 72 700 Tm (A paragraph line over a list set tight under it.) Tj ET\n",
+    );
+    for (y, item) in [(686, "First"), (672, "Second"), (658, "Third")] {
+        list += &format!(
+            "BT /F1 12 Tf 1 0 0 1 72 {y} Tm (\\225) Tj ET\n\
+             BT /F1 12 Tf 1 0 0 1 86 {y} Tm ({item} item of the list) Tj ET\n"
+        );
+    }
+    let list = units(&list);
+    assert_eq!(of(&list), [1, 2, 2, 3, 3, 4, 4], "{list:?}");
+
+    // Each word drawn on its own, 3 points after the one before it ends, and no space drawn.
+    let mut contents = String::new();
+    for (y, words) in [
+        (
+            700,
+            [
+                (72.0, "Statement"),
+                (129.7, "of"),
+                (142.71, "comprehensive"),
+                (227.07, "income"),
+                (268.75, "and"),
+                (291.77, "expense"),
+            ],
+        ),
+        (
+            686,
+            [
+                (72.0, "Balance"),
+                (118.36, "sheet"),
+                (150.71, "and"),
+                (173.73, "its"),
+                (188.73, "notes"),
+                (221.08, "here"),
+            ],
+        ),
+        (
+            672,
+            [
+                (72.0, "Cash"),
+                (103.01, "flow"),
+                (127.35, "statement"),
+                (183.04, "and"),
+                (206.06, "related"),
+                (245.74, "notes"),
+            ],
+        ),
+    ] {
+        for (x, word) in words {
+            contents += &format!("BT /F1 12 Tf 1 0 0 1 {x} {y} Tm ({word}) Tj ET\n");
+        }
+    }
+    let contents = units(&contents);
+    assert_eq!(
+        of(&contents),
+        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2],
+        "{contents:?}"
+    );
+}
+
 /// **The `images` proof, both halves** (v1-S6).
 ///
 /// A page that PAINTS an image yields a node carrying where it was drawn and which bytes it is.
diff --git a/docs/00-NORTH-STAR.md b/docs/00-NORTH-STAR.md
index 3735bbc..1874567 100644
--- a/docs/00-NORTH-STAR.md
+++ b/docs/00-NORTH-STAR.md
@@ -95,6 +95,8 @@ first that refuses a measured performance win on honesty grounds, and it names t
 | 63 | **DECIDED 2026-10-11. A script is part of the line it is set in.** Told "Grounding: text blocks", the `Text` elements visual grounding could not place were counted by why: missing (0.052 of the score, much of it pages that crop, decision #62), covered by a bigger item of ours (0.041: figure regions over panels, tables, KPI numbers with their captions), one item of ours barely over them (0.024), split across several (0.014). On mathematics and chemistry the units broke at every subscript and superscript: a script sits on a baseline of its own, inside its unit's box rather than below it, so it was a unit of its own and the line around it several. `line-units-v4`: a line set under seventeen twentieths of the line before it in reading order, its baseline within half that line's height, inside that line's extent past its start, is that line's, read against that line's own box. **The trade, taken by the owner**: 40 pages up and 10 down, where joined units outgrow the ground truth's blocks (a drop cap rejoining its paragraph, the TeX logo's lowered `E`).<br><br>**Measured**: visual grounding 0.5268 → 0.5316; content one page down by 0.00003; formatting, tables and charts unchanged on every page; opendataloader-bench, the gate documents' tables and the heading bounds unchanged; overall 45.73 → 45.82. Not used: a line inside its unit's band joining it (0.5272, 21 up and 8 down), joining a smaller line stacked under its line (falls on KPI pages), grouping a unit's non-consecutive items in the adapter (0.5280, 20 up and 8 down), dropping figure regions that hold text (every variant lower). |
 | 64 | **DECIDED 2026-10-11. A line set a weight heavier than its text is read as a bold one — and the owner took the label tier's cost.** Told "Headings on layout pages", the section headers ParseBench's visual grounding finds and this engine read as text were counted by what sets them apart: 320 are short lines set within 15% of the text's size in no bold face, 258 of them in a face other than the text's, commonest the text's own family a weight heavier (`NewFrank-Medium` over `NewFrank-Light`, `Graphik-Medium` over `Graphik-Regular`) — and the bold clause reads a face bold only from a weight class of 600. `type-size-v7`: each font's weight class is read — its descriptor's `/FontWeight`, its embedded program's `OS/2` class, else a weight word in its name's style — and a run set a class or more heavier than the class most of its page's characters are set in counts as bold for the bold clause and the label tier; the run's `bold` does not move, so no projection emphasises it, and the class is never on the wire (`docs/measurements/headings/README.md` §13). Shown it measured both ways, the owner chose "Labels too, bigger trade". **The trade:** the `#` headings of the eleven tagged documents read as under `-v6`, but the label tier reads 20 more lines on `cfpb-home-loan-toolkit`, 12 against its tags; against ParseBench's ground truth 199 more section headers read as headings and 49 text elements as headings they are not (a report's navigation tabs, a list of values set a weight up), 18 grounding pages fall, and a heading broken after a hyphen became two `#` lines (content `text_multicolumns__mckinsey` 0.960 → 0.933).<br><br>**Measured**: visual grounding 0.5367 → 0.5435, 43 pages up and 18 down; content faithfulness 0.6696 → 0.6695; formatting, tables and charts unchanged on every page; overall 45.92 → 46.06; opendataloader-bench MHS 0.5457 → 0.5854, 6 documents up and none down, NID up on 5 and down on none, TEDS and the gate documents' tables unchanged. Not used: the heavier weight read only where a line stands apart, labels as under `-v6` — the bounds identical to `-v6`'s, grounding 0.5389, 19 up and 4 down. |
 | 65 | **DECIDED 2026-10-12. A heading's section number and its title are one line, and a label's lines one block.** Told "Formatting titles", the 1,872 title checks on ParseBench's formatting pages were read for why each fails: 812 pass and 247 sit on pages with no text layer; a title's words absent or changed in our text — an OCR layer's errors, a curly apostrophe, a broken ligature — 311; a title set on several lines whose first only is a heading or a bold line, about 150; a section number and its title a tab apart, written as two headings; and 235 on 75 tagged documents whose tree tags every title `/P` and declares no heading. Folded into the unreleased `markdown-blocks-v12` / `html-blocks-v12`: both projections join a heading's title to its section number or marker across the gap where both are inferred headings of one level on the one line the heading rule read, the open block is the number alone and the title is drawn after it and holds a letter (`heading-number-joins-v1`); and a label's next line in its unit, which its column did not wrap, continues the label's block on a line of its own. **Every bound holds, so no trade was put to the owner.**<br><br>**Measured**: semantic formatting 0.4402 → 0.4512, 20 documents up and none down; content faithfulness 0.6695 → 0.6700, 9 up and none down; tables, charts and grounding unchanged on every page; opendataloader-bench MHS 0.5854 → 0.5872 and one document's NID up, none down; overall 46.06 → 46.29. Not used: the join across any gap (46.40, but it welds two columns' headings, folios, column headers and text drawn twice; 14 pages down); every label's lines broken, wrapped ones included (10 formatting documents down); headings inferred on a tagged document whose tree declares none (formatting 0.4573, but content down on 15 pages, one 0.95 → 0.59, and every such document's projections change, which `docs/28-HEADINGS-SCOPE.md` §7.5 bar 3 forbids — the owner's call). |
+| 66 | **DECIDED 2026-10-13. A line chart that prints its values is read as its table — and the owner took the opendataloader-bench trade.** Told "Charts, round 3", the 846 chart points that print their value and failed were read for why: 284 on pages whose bars the bar rule never found (lines, pies, images), 328 on pages whose bars it refused, 234 on pages whose table missed them — each reason small. Shown that each bar fix moved about a page, the owner chose "Build the line-chart rule"; shown the prototype at a third of the estimate, "Port what's measured". A new field, `table_detection.lines` = `point-labels-v1`: a stroked line rising left to right, or a run of small marks, is a series; each number goes to the one point it is set at unless another series' point stands nearly as near; a year is never a value; six points in ten must carry one and a higher point never a smaller one; categories are the row of labels under the plot; series are named by their legend swatches, or alone by the title. The interpreter carries the stroke colour and records stroked subpaths and small filled marks for it alone. And `bar-labels-v2` → `-v3`: the title over a chart names its one series that prints numbers. `docs/32-CHART-LABELS-SCOPE.md` §8, §9. **The trade:** opendataloader-bench `01030000000078`'s line now reads as a table right against its drawing, and its ground truth's loose labels move that document's NID 0.8786 → 0.8099 and TEDS 0.8667 → 0.7086 — decision #42's trade, on one document more.<br><br>**Measured**: ParseBench charts 0.1184 → 0.1248, 7 pages up and none down; tables, content, formatting and grounding unchanged on every page; overall 46.29 → 46.42; no line table on a table or text page; the gate documents' tables unchanged. Not used: rounded bars (§7's measurement, again), panels merged across a shared category axis, a series named by a label set on its line, a transposed reader for markers down a column. |
+| 67 | **DECIDED 2026-10-13. A line is read where the reading order reads it, and its words where the page set them apart — and the owner took the trade.** Told "Grounding: text, round 2", the `Text` elements visual grounding could not place were counted by how our items sit on them: split across several of ours (811, 0.051 of the score), nothing of ours over them (520, 0.032: pages drawn as images, figure regions, panels read as ruled tables), one item of ours far bigger (483, 0.023), ours covering under half (182, 0.015). The largest split was a page the reading order did not divide: a line was every run on its baseline across the page, read where its first run was, so a paragraph sharing its baselines with a byline in the next column fell into several units. `layout_unit_rule` `line-units-v4` → `-v5`: each line is cut into its pieces before any unit is read, and a line as the units read it is the pieces of one line that follow each other in reading order; and the text the list-marker clause and the first word are read from has a space wherever two runs' boxes stand a tenth of the line's height apart, so a bullet set apart by its position opens an item and the hard-break cut reads a first word as a word. **The trade:** the across-columns line had given each unit a far right edge that cut some by accident — a contents list's entries (Marico p4, twice in the set), a paragraph's or a label's last line — and those now join; basf p17's ground truth keeps a bullet list as one block, now a unit per bullet; one chart's labels join the text beside it.<br><br>**Measured**: ParseBench visual grounding 0.5435 → 0.5575, 119 pages up and 8 down; content one page up by 0.0003; tables, charts and formatting unchanged on every page; overall 46.42 → 46.70; opendataloader-bench, the fabrication check and the gate documents' tables unchanged. The lines alone 0.5546 (109 up, 12 down); the space at a quarter of the line's height 0.5564, at a twentieth 0.5577 (2 up and 2 down against a tenth). |
 
 ## 3. Trust ladder — who owns what
 
diff --git a/docs/32-CHART-LABELS-SCOPE.md b/docs/32-CHART-LABELS-SCOPE.md
index 551c3d5..cacc0c1 100644
--- a/docs/32-CHART-LABELS-SCOPE.md
+++ b/docs/32-CHART-LABELS-SCOPE.md
@@ -1,6 +1,6 @@
 # A bar chart's printed labels as its table — scope (decision #42)
 
-**Status: shipped 2026-10-04 as `bar-labels-v1`; `bar-labels-v2` since 2026-10-09 (§7, decision #57).** A bar chart that prints its numbers states a
+**Status: shipped 2026-10-04 as `bar-labels-v1`; `bar-labels-v2` since 2026-10-09 (§7, decision #57); `bar-labels-v3` and a line chart's rule, `point-labels-v1`, since 2026-10-13 (§8, §9, decision #66).** A bar chart that prints its numbers states a
 table; this rule reads that table back. It never reads a value off a bar's length: a bar that carries
 no number leaves its cell empty, and a chart that prints none yields no table.
 
@@ -125,7 +125,8 @@ on that page returned to its score before the rule.
 ## 6. Not done
 
 - **Line charts**: markers and polylines as the witness, measured in the prototype at +0.002 with
-  more ways to go wrong; not in this rule.
+  more ways to go wrong; not in this rule. **Read since decision #66** by a rule of their own,
+  `point-labels-v1` (§9).
 - **Pie charts, rotated labels, charts in images.**
 - **Charts that print no numbers**: reading a value off a bar's length would be estimating, which
   this engine refuses.
@@ -185,3 +186,83 @@ or as much down as up.
 (`ADL_Future_of_automotive_mobility` p13: `3.73.6`); small multiples, whose data points name a panel
 as well as a category and a series; categories in two tiers; bars hanging below a base; a line
 drawn over the bars; pies and lines (§6).
+
+## 8. `bar-labels-v3`: the title over a chart names its one series that prints numbers (2026-10-13, decision #66)
+
+`-v2` read the title over a chart as its series' name only where the chart was drawn in one colour.
+A chart of bars drawn over a full-length track — a progress bar, one colour printing its numbers
+and one printing none — kept two series, and its one column of numbers went unnamed, though the
+panel's title over it names it (`(Web_version)_E-Government_Survey_2024` p78, three panels each
+titled). `-v3` reads the title for the one series that carries numbers, whatever else is drawn
+beside it, and a series with no number is still no column. Measured alone: ParseBench charts
+0.1184 → 0.1202, that page 0 → 1.0, nothing else moved.
+
+**Measured beside it and not used:** rounded bars read as bars (one page given a table, and it
+still scored nothing without its legend's dots — as `-v2` measured them, §7); panels sharing a
+category axis merged into one table (at most fifteen pages and 66 points, each needing the panel's
+title and the legend as well).
+
+## 9. `point-labels-v1`: a line chart's printed values (2026-10-13, decision #66)
+
+**Why.** Told "Charts, round 3", the 846 chart data points that print their value and still failed
+were read for why: 284 sat on pages where the bar rule found no bars at all — line charts, pies,
+charts drawn as images — 328 on pages whose bars it refused, and 234 on pages whose table missed
+them, the reasons many and each small. The largest coherent piece left was a line chart that prints
+a number at each point: about eight pages. Round 1's prototype read lines and measured +0.002; its
+reasons were found and mended before this rule was written (below).
+
+**The rule.** Its own profile field, `table_detection.lines`, beside the bar rule's: the evidence —
+stroked lines, small marks, their colours, and the labels set at their points — is its own. It runs
+after `bar-labels-v3`, on runs no other rule's table holds, only on a document that declares no
+author structure, and keeps a table only where it overlaps none already found.
+
+1. **Strokes and marks.** The interpreter carries the stroke colour as it carries the fill (`G`,
+   `RG`, `K`, `SC`, `SCN`, reset by `CS`, saved by `q`), and records each subpath a stroke paints —
+   every point a line or a curve ends at — with it, and the box of each filled path a point to
+   fifteen points each way and near square, with its fill. Nothing else reads either.
+2. **A series** is a stroked line of three points or more, each standing more than half a point
+   right of the one before it, not all at one height — a line drawn twice read once — or three
+   marks or more of one colour and size so set. A line drawn through a run of marks is that run;
+   marks all on a longer line are the line.
+3. **A value** is a number set at one point: centred over or under it within a line and a half, or
+   beside it on its height within a line and a fifth. Every number goes to its nearest point over
+   every series of the page, and **is no one's where another series' point stands nearly as near**
+   (within one and a half times the distance and a third of a point) — round 1 asked each series
+   alone, so two lines running close read each other's numbers as ambiguous and neither kept any.
+   Each point keeps its nearest number. **A year is never a value**: a timeline's dates set at its
+   marks, or a year axis set along a line, read so were a table of dates. A number set on a bar is
+   the bar's.
+4. **A series keeps its numbers** only where six points in ten carry one, and **a point clearly
+   higher on the page never carries a smaller number** (by half a line).
+5. **Categories** are the first row of labels below the plot — below the lowest point of every
+   series set at the same places, of the forty rows below it — holding one label under eight points
+   in ten, no label twice and at most half of them numbers but years. Round 1 looked twelve rows
+   below each series' own lowest point, under which a chart's other series print their numbers,
+   and refused a tenor's `3M` as a number.
+6. **A table** is every series reading one row of categories, a row per category in the order its
+   points stand, a column per series, each named by the block of lines beside a legend swatch of its
+   colour — a small mark or a short level stroke, its name read line by line up to the next swatch
+   — or, alone, by the one-line title over it, measured from its highest number. A cell holds
+   exactly its label's runs; an empty cell is not emitted; a value is never read off a point's
+   height.
+
+**Measured**, with the shipped build on all 2,078 ParseBench pages and opendataloader-bench's 200,
+against decision #65's: ParseBench charts **0.1184 → 0.1248**, seven pages up and none down
+(`She-figures` p88 and `E-Government_Survey` p78 0 → 1.0, `2022_SPI_Benchmark_Executive_Summary`
+p19 0 → 0.6 and p20 0 → 0.4, `article_thebeatjun2025` p34 0 → 0.3, `Technopak_Industry_Report` p4
+0 → 0.2); tables, content, formatting and visual grounding unchanged on every page; overall 46.29
+→ 46.42. Seventeen line tables on the chart and layout pages — `She-figures` p88, `article_thebeatjun2025`
+p22 and opendataloader-bench `01030000000078` checked against their drawings — none on a table or
+text page; the gate documents' 539 tables unchanged; every cell its runs' text.
+
+**The trade, taken by the owner.** opendataloader-bench `01030000000078` draws ASEAN's remittances
+as bars and the world's as a line over them; the line now reads as its table, right against the
+drawing (`World (left axis)`: 610, 602, 597, 640, 694, 719, 702 for 2014–2020). Its ground truth
+keeps the chart's labels as loose lines, so that document's NID falls 0.8786 → 0.8099 and its
+TEDS 0.8667 → 0.7086 (the bench's NID 0.8841 → 0.8838, TEDS 0.5339 → 0.5301) — the trade decision
+#42 took for bar charts, on one document more, and this time on its table score too.
+
+**Measured and not used.** A series named by a label set on the line itself, at its first or last
+point (moved no page); the transposed reader, for markers set down a column with their categories
+beside them, was not built.
+
diff --git a/docs/CAPABILITY.md b/docs/CAPABILITY.md
index 3b4d47a..ceae580 100644
--- a/docs/CAPABILITY.md
+++ b/docs/CAPABILITY.md
@@ -29,13 +29,13 @@ Everything below runs locally, with no network and no renderer.
 | **Locate** | Reports **where** a string lies in a representation and nothing else: occurrences as node ids, character offsets into each node's own text in Unicode scalars, and that node's own geometry copied from the record. Exact on scalars — no normalization, no case folding, no whitespace folding — over each block of the reading order, so a match may join runs inside one block and **never across two**; the artifact declares what it searched. **No box is bound tighter than a run**: an occurrence carries the run's own rectangle, never a sub-run or word box ([`22-WORD-BOXES-SCOPE.md`](22-WORD-BOXES-SCOPE.md) refused those on measurement). A string that occurs nowhere is exit 0 and an empty list — there is no verdict, no score, and no exit 1 | `locate`, `mcp`, `packages/` |
 | **Adapters** | MCP over stdio, a Python SDK, a Node SDK, and LangChain tools over both. Every locator is minted by the engine, handed back opaque, and re-validated on the way in. No adapter takes a geometry argument. **MCP's `markdown` tool gives a model the text to read**: the text the `markdown` command prints, from a file's `path` or a representation, after a count of what it leaves out, and no anchor map — the one Markdown that travels without its map, by decision #36, so a passage is cited through `locate` | `mcp`, `packages/` |
 | **Format detection** | Decided by reading bytes at offset 0, never by file name or extension. Bytes that state no known format are refused by naming what was looked for, and nothing else. A `.csv`, a letter and a log line all get byte-identical stderr | `extract` |
-| **Tables** | Row/column model with spans and cell occupancy, six named detection rules (`ruled-rects-v12`, `unruled-align-v1`, `stroke-ruled-v1`, `tagged-tables-v1`, `whitespace-tracks-v14`, `bar-labels-v2`), and a cross-check between what the geometry says and what the document's own tags say. Where the two disagree structurally, the rule refuses the grid rather than emitting it. **The ruled rule takes either of two shapes of evidence**: every implied cell covered by ink, or every row and column boundary carried end to end by the rectangle edges lying on it. Neither subsumes the other — a merged cell breaks an interior line, a rules-only grid draws no cell — so either suffices and nothing `-v3` emitted was lost. A grid accepted by its lines has a cell for each face (`ruled-rects-v7`); `-v6` emitted it with none. **Where the page's rectangles as one lattice are refused, each group of them that touch is a candidate of its own** (`ruled-rects-v8`): a footer's rule or another table no longer refuses a grid drawn whole, and a group's grid stands only where it is not one band of a shaded table, does not fold rows the page left unruled, does not run on into a wider table, and splits no column the text does not; and a group's grid whose interior lines stop at merged cells is read with them merged (`ruled-rects-v10`), never where a cell would span rows whose lines sit on its neighbours' baselines, and never from a rectangle filled white; a rectangle a group paints twice is one rectangle (`ruled-rects-v11`); and on a document that declares no author structure a group leaves out a fill painted over paint of its own colour and a rule neither of whose ends meets another rectangle (`ruled-rects-v12`). **Since decision #38 a grid is also inferred from the whitespace across a table's rows** (`whitespace-tracks-v14`, `docs/31-TABLE-TRACKS-SCOPE.md`), run page-wide and again inside each of a page's columns where one is prose, with a header set on several lines above the first row read as one row, a header cell set off its column given the column whose centre is nearest (decision #49), and two numbers set closer than an em read as two cells where that makes the line a row (decision #51), a line wider than the table re-tracking it under three rows of data and a row its wrapped cell made tall reaching past the pitch (decision #52), a cell of several numbers a word space apart read as as many cells (decision #53), and two flows of numbers set side by side each read on its own (decision #60): rows at a steady pitch, columns kept by centre, left or right edge so a right-aligned column of numbers is a column — a currency sign set alone joining its amount, a raised footnote mark its row, each track growing with the rows — and the content stream writing it row by row, which is what tells it from two columns of prose, waived for a grid of three rows and three columns or more with a column of numbers, no column of running text and no two flows side by side — a first column holding a short label in every row, written as one block before the values, being the table's own (decision #56), and a header's last line, read as the first row, being the header's (decision #58). Two rows stand only complete, apart and under a header-like row; two columns need four rows and are no table beside a column of list labels or of rising page numbers. It runs last and only on a document that declares no author structure, and a cell holds only its runs' text. **Measured:** opendataloader-bench TEDS 0.1728 → 0.4254 with no table on any of the 158 documents whose ground truth holds none (0.3918 under `-v2`; `ruled-rects-v7` brings the rest). Two short rows close together can still share one row, taken as a wrap; no merged cell is inferred. **Since decision #42 a bar chart that prints its numbers is read as its table** (`bar-labels-v2`, `docs/32-CHART-LABELS-SCOPE.md`): each filled bar paired with the one number on it or just past its end and the one label at its base, series named by the legend swatch of their colour or a one-colour chart's title line, grouped and stacked bars included — groups read from the gaps between them where their colours repeat in no period, bars coloured one per category read as one series, and a bar drawn with its corners named twice read as one (decision #57) — a table only where the numbers agree with the bars in order and most bars of a series carry one, on a document that declares no author structure. **A value is never read off a bar's length**, so a chart that prints no numbers yields no table; line and pie charts are not read | `extract` |
+| **Tables** | Row/column model with spans and cell occupancy, seven named detection rules (`ruled-rects-v12`, `unruled-align-v1`, `stroke-ruled-v1`, `tagged-tables-v1`, `whitespace-tracks-v14`, `bar-labels-v3`, `point-labels-v1`), and a cross-check between what the geometry says and what the document's own tags say. Where the two disagree structurally, the rule refuses the grid rather than emitting it. **The ruled rule takes either of two shapes of evidence**: every implied cell covered by ink, or every row and column boundary carried end to end by the rectangle edges lying on it. Neither subsumes the other — a merged cell breaks an interior line, a rules-only grid draws no cell — so either suffices and nothing `-v3` emitted was lost. A grid accepted by its lines has a cell for each face (`ruled-rects-v7`); `-v6` emitted it with none. **Where the page's rectangles as one lattice are refused, each group of them that touch is a candidate of its own** (`ruled-rects-v8`): a footer's rule or another table no longer refuses a grid drawn whole, and a group's grid stands only where it is not one band of a shaded table, does not fold rows the page left unruled, does not run on into a wider table, and splits no column the text does not; and a group's grid whose interior lines stop at merged cells is read with them merged (`ruled-rects-v10`), never where a cell would span rows whose lines sit on its neighbours' baselines, and never from a rectangle filled white; a rectangle a group paints twice is one rectangle (`ruled-rects-v11`); and on a document that declares no author structure a group leaves out a fill painted over paint of its own colour and a rule neither of whose ends meets another rectangle (`ruled-rects-v12`). **Since decision #38 a grid is also inferred from the whitespace across a table's rows** (`whitespace-tracks-v14`, `docs/31-TABLE-TRACKS-SCOPE.md`), run page-wide and again inside each of a page's columns where one is prose, with a header set on several lines above the first row read as one row, a header cell set off its column given the column whose centre is nearest (decision #49), and two numbers set closer than an em read as two cells where that makes the line a row (decision #51), a line wider than the table re-tracking it under three rows of data and a row its wrapped cell made tall reaching past the pitch (decision #52), a cell of several numbers a word space apart read as as many cells (decision #53), and two flows of numbers set side by side each read on its own (decision #60): rows at a steady pitch, columns kept by centre, left or right edge so a right-aligned column of numbers is a column — a currency sign set alone joining its amount, a raised footnote mark its row, each track growing with the rows — and the content stream writing it row by row, which is what tells it from two columns of prose, waived for a grid of three rows and three columns or more with a column of numbers, no column of running text and no two flows side by side — a first column holding a short label in every row, written as one block before the values, being the table's own (decision #56), and a header's last line, read as the first row, being the header's (decision #58). Two rows stand only complete, apart and under a header-like row; two columns need four rows and are no table beside a column of list labels or of rising page numbers. It runs last and only on a document that declares no author structure, and a cell holds only its runs' text. **Measured:** opendataloader-bench TEDS 0.1728 → 0.4254 with no table on any of the 158 documents whose ground truth holds none (0.3918 under `-v2`; `ruled-rects-v7` brings the rest). Two short rows close together can still share one row, taken as a wrap; no merged cell is inferred. **Since decision #42 a bar chart that prints its numbers is read as its table** (`bar-labels-v3`, `docs/32-CHART-LABELS-SCOPE.md`): each filled bar paired with the one number on it or just past its end and the one label at its base, series named by the legend swatch of their colour or the title over a chart whose one series prints numbers (decision #66), grouped and stacked bars included — groups read from the gaps between them where their colours repeat in no period, bars coloured one per category read as one series, and a bar drawn with its corners named twice read as one (decision #57) — a table only where the numbers agree with the bars in order and most bars of a series carry one, on a document that declares no author structure. **A value is never read off a bar's length**, so a chart that prints no numbers yields no table; **since decision #66 a line chart that prints a number at each of its points is read the same way** (`point-labels-v1`): a stroked line rising left to right, or a run of small marks, each number given to the one point it stands over, under or beside unless another line's point stands nearly as near, a year never a value, the categories the row of labels under the plot, each series named by its legend swatch — and pie charts are not read | `extract` |
 | **Fabrication** | **0** across the twelve-document labelled set. Measured every run, not asserted | `table-gate-v1.md` |
 | **Table accuracy** | Stated as a capability, not an average, re-measured at 0.58.0: the engine reads the tables a document **declares** (162 of 172 gold tables emitted from their tags; combined cell-slot recall **503‰**) and **detects** ruled tables where the producer drew them (geometric macro F1 **69‰**, band 0‰–590‰, median 0‰ — ten of twelve score zero). It emits nothing where neither holds | `table-gate-v1.md` |
 | **Fuzzing** | Three `cargo-fuzz` targets covering the PDF entry points and the office router. One campaign ran 3.8M executions under AddressSanitizer and found nothing. Mutation testing damages every PDF fixture six ways and every office package twelve | `fuzz/` |
 | **Layout regions** | Every text run says which region of its page the reading-order cut placed it in, 1-based in reading order, under `gutter-columns-v4`. **A region is a column band**: runs stacked within one column share a region however many paragraphs separate them, and the field is absent wherever the cut made no division — which is most pages. **Such a page is read top to bottom by its leading-gap blocks** (below), content-stream order kept inside each, since decision #32 (2026-09-26): on opendataloader-bench NID 0.8714 → 0.8810 with the 74 documents already read in one downward sweep unmoved, and a page set in columns the cut cannot divide is read across them where they break at one height. It is `Computed` geometry and never a role: no heading, paragraph or section is read from it | `extract` |
 | **Layout blocks** | Every text run says which block of its page the cut's horizontal half placed it in, 1-based in reading order, under `gutter-columns-v4`. **A block is a stretch of text separated from its neighbours by whitespace wider than its band's own leading** — it is not a paragraph, a heading or a list item, and no role is read from it (P14). Measured on the one gate document able to carry a real paragraph label: **63.7% of real paragraph breaks at 100% precision**, never firing mid-paragraph across 719 chances. The third it misses is a ceiling rather than a shortfall — 35.1% of real breaks carry no extra leading for any gap rule to see. Absent wherever the rule declined, which includes every page of uniform body text. Its limits — whitespace only, no indent branch, recall measured on one document — are declared on every PDF artifact as `block-subdivision-leading-gap-only` | `extract` |
-| **Layout units** | Since decision #38, on a document that declares no author structure, every text run says which layout unit of its page its line joined, 1-based in reading order, under `line-units-v4`: consecutive lines set no more than half a line apart, overlapping across, of one kind — body text, or an inferred heading of one level — the next opening no list marker, and since `line-units-v2` cut where a piece of text — a line's runs, cut at a gap wider than its height — follows one that ends short, and since `line-units-v3` before a body line whose first word would have fit twice over after the line above: a break its author made, not its measure. Since `line-units-v4` (decision #63) a script — a subscript, a superscript, a footnote mark on a baseline of its own — is part of the line it is set in. **A unit is where, never what**: it says lines read as one piece of text, not that the author wrote a paragraph. A table's runs and an `/Artifact`'s get none. Measured on ParseBench's visual-grounding pages, where layout items built from units score above line items. Markdown and HTML join a heading unit's lines, counted as `layout-unit-line-joins-v1`, so a heading set on two lines is one heading line; body text keeps its lines | `extract`, `markdown`, `html` |
+| **Layout units** | Since decision #38, on a document that declares no author structure, every text run says which layout unit of its page its line joined, 1-based in reading order, under `line-units-v5`: consecutive lines set no more than half a line apart, overlapping across, of one kind — body text, or an inferred heading of one level — the next opening no list marker, and since `line-units-v2` cut where a piece of text — a line's runs, cut at a gap wider than its height — follows one that ends short, and since `line-units-v3` before a body line whose first word would have fit twice over after the line above: a break its author made, not its measure. Since `line-units-v4` (decision #63) a script — a subscript, a superscript, a footnote mark on a baseline of its own — is part of the line it is set in. Since `line-units-v5` (decision #67) a line is the pieces of one baseline that follow each other in reading order, so a baseline running across columns the reading order reads apart is a line per column, and a line's text has a space where its words stand a tenth of its height apart with none drawn, so a bullet set apart by its position opens a list item and a line's first word is read as a word. **A unit is where, never what**: it says lines read as one piece of text, not that the author wrote a paragraph. A table's runs and an `/Artifact`'s get none. Measured on ParseBench's visual-grounding pages, where layout items built from units score above line items. Markdown and HTML join a heading unit's lines, counted as `layout-unit-line-joins-v1`, so a heading set on two lines is one heading line; body text keeps its lines | `extract`, `markdown`, `html` |
 | **Page furniture** | Since decision #41, on a document that declares no author structure, a run whose line is a page's running head or folio carries `furniture` — `header` or `footer` — under `margin-bands-v1`: a page's lines and tables are grouped into bands wherever half a body line or more separates them, and the first band is the header and the last the footer when it lies wholly inside the page's outer tenth, holds no table, and is not the page's only band. **Where, never what was meant**: a page title set apart at the top reads as a header too. Nothing is dropped — the runs stay in the text and in every projection. On the eight tree-stripped gate documents it flags 5,070 lines, all but four repeated page to page, and those four a form's running head and folio, its catalogue number and a cover's date. On ParseBench visual grounding moved 0.4045 -> 0.4490 | `extract` |
 | **Figure regions** | Since decision #46, on a document that declares no author structure, the paths a page paints are read as figures under `figure-regions-v1` (`docs/34-FIGURE-REGIONS-SCOPE.md`): every path a fill or a stroke paints, on the page and in its forms, less its background and the panels text is set on, clustered wherever their boxes come within 3 points; a cluster of 3 paths or more covering 0.05% to 80% of the page, less than half inside a table and holding no line of prose is a `FigureRecord` in the representation's `figures` array — a box and the rule id, `Computed`. **Where, never what**: a region claims no run and names no caption, and neither projection writes it. Not read: a row of icons along one rule (one region), the text inside a figure, and a raster image with the paths drawn over it. On ParseBench visual grounding moved 0.4708 -> 0.4824 | `extract` |
 | **Bold and italic** | A run carries `bold` or `italic` where the font that drew it declares the style — a `/FontWeight` of 600 or more, the ForceBold or Italic flag, or `Bold`, `Black`, `Heavy`, `Semibold`, `Demibold`, `Italic` or `Oblique` in its `/BaseFont` — and since `page-observations-v4` where the TrueType or OpenType program it embeds states one (`OS/2` weight class 600 or more, or `head`'s macStyle where it has no `OS/2`; the italic or oblique bit), and a run painted fill-then-stroke (rendering mode 2 or 6) is bold; the Markdown and HTML projections write `**`/`*` and `<strong>`/`<em>`, never inside a heading or a table cell (decision #38). Nothing is read from stem widths or outlines, nor from a bare CFF or Type 1 program. Nothing is estimated from stem widths or outlines. PDF only; the office readers do not set it yet. On ParseBench semantic formatting moved 0.097 -> 0.349 | `extract`, `markdown`, `html` |
diff --git a/docs/PUBLIC-API.md b/docs/PUBLIC-API.md
index 6f8cd4f..66a07d2 100644
--- a/docs/PUBLIC-API.md
+++ b/docs/PUBLIC-API.md
@@ -46,7 +46,7 @@ the items re-exported at the crate root.
 | `html` | `to_html`, `HtmlArtifact`, `HTML_ARTIFACT_TYPE`, `HTML_SCHEMA_VERSION`, `HTML_RULE_BLOCKS_V12` |
 | `markdown` | `to_markdown`, `AnchorMap`, `Segment`, `SegmentKind`, `Coverage`, `DroppedBucket`, `StructuralErasure`, `MarkdownArtifact`, `MARKDOWN_ARTIFACT_TYPE`, `MARKDOWN_SCHEMA_VERSION`, `MARKDOWN_RULE_BLOCKS_V12`, `GFM_SPAN_SLOTS_UNREPRESENTABLE`, `GFM_ROW_ZERO_SEPARATOR`, `GFM_CELL_RUN_CLAIMED_TWICE`, `GFM_CELL_NOT_PLACED`, `GFM_TABLE_NOT_PROJECTED`, `GFM_LIST_ITEM_RUN_JOINS`, `MCID_RUN_JOINS`, `BASELINE_RUN_JOINS_ABUTTED`, `BASELINE_RUN_JOINS_SPACED`, `LAYOUT_UNIT_LINE_JOINS`, `HEADING_NUMBER_JOINS` (**new with decision #65**), `HEADING_LEVEL_UNRESOLVED`, `HEADING_LEVEL_UNREPRESENTABLE` |
 | `locate` | `locate`, `Locations`, `Occurrence`, `OccurrencePart`, `OccurrencesWithheld`, `Searched`, `LOCATIONS_ARTIFACT_TYPE`, `LOCATIONS_SCHEMA_VERSION`, `LOCATE_RULE_V1`, `LOCATE_MAX_QUOTE_BYTES`, `LOCATE_MAX_OCCURRENCES` — **new at v2.3**. Where a string lies in a representation, and nothing else: no verdict, no score, and a string occurring nowhere is an empty answer rather than an error. The two ceilings are `ethos.grounding.v1`'s own, re-declared because this crate may not depend on the grounding crate and asserted equal by a test that can see both |
-| `profile` | `Profile`, `profile_sha256`, `BackendIdentity`, `Capabilities`, `PageBudget`, `XrefRepair`, `VerifierPin`, `TableDetection`, `CMAP_DATA_VERSION`, `READING_ORDER_RULE_V0`, `READING_ORDER_RULE_V1`, `READING_ORDER_RULE_V2`, `READING_ORDER_RULE_V3`, `READING_ORDER_RULE_V4` (**new with decision #32**), `OBSERVATION_RULE_V3`, `OBSERVATION_RULE_V4` (**new with page-observations-v4**), `TEXT_CODE_RULE_V2`, `TEXT_CODE_RULE_V3` (**new with decision #43**), `TEXT_CODE_RULE_V4` (**new with decision #44**), `RasterDpi`, `NOT_RUN`, `DOCX_READING_ORDER_RULE_V2`, `DOCX_TEXT_CODE_RULE_V3`, `XLSX_READING_ORDER_RULE_V1`, `XLSX_TEXT_CODE_RULE_V3`, `PPTX_READING_ORDER_RULE_V1`, `PPTX_TEXT_CODE_RULE_V3`, `ODT_READING_ORDER_RULE_V1`, `ODT_TEXT_CODE_RULE_V2`, `ODS_READING_ORDER_RULE_V1`, `ODS_TEXT_CODE_RULE_V2`, `ODP_READING_ORDER_RULE_V1`, `ODP_TEXT_CODE_RULE_V2`, `RTF_READING_ORDER_RULE_V1`, `RTF_TEXT_CODE_RULE_V2`, `EPUB_READING_ORDER_RULE_V1`, `EPUB_TEXT_CODE_RULE_V2`, `TABLE_DETECTION_V1`, `TABLE_DETECTION_V2`, `TABLE_DETECTION_V3`, `TABLE_DETECTION_V4`, `TABLE_DETECTION_V5`, `TABLE_DETECTION_V6`, `TABLE_DETECTION_V7` (**new with ruled-rects-v7**), `TABLE_DETECTION_V8` (**new with ruled-rects-v8**), `TABLE_DETECTION_V9` (**new with ruled-rects-v9**), `TABLE_DETECTION_V10` (**new with ruled-rects-v10**), `TABLE_DETECTION_V11` (**new with ruled-rects-v11**), `TABLE_DETECTION_V12` (**new with ruled-rects-v12**), `TABLE_DETECTION_UNRULED_V1`, `TABLE_DETECTION_STROKE_V1`, `TABLE_DETECTION_TAGGED_V1`, `TABLE_DETECTION_TRACKS_V3`, `TABLE_DETECTION_TRACKS_V4` (**new with whitespace-tracks-v4**), `TABLE_DETECTION_TRACKS_V5` (**new with whitespace-tracks-v5**), `TABLE_DETECTION_TRACKS_V6` (**new with whitespace-tracks-v6**), `TABLE_DETECTION_TRACKS_V7` (**new with decision #49**), `TABLE_DETECTION_TRACKS_V8` (**new with decision #51**), `TABLE_DETECTION_TRACKS_V9` (**new with decision #52**), `TABLE_DETECTION_TRACKS_V10` (**new with decision #53**), `TABLE_DETECTION_TRACKS_V11` (**new with decision #55**), `TABLE_DETECTION_TRACKS_V12` (**new with decision #56**), `TABLE_DETECTION_TRACKS_V13` (**new with decision #58**), `TABLE_DETECTION_TRACKS_V14` (**new with decision #60**), `TABLE_DETECTION_CHARTS_V1` (**new with decision #42**), `TABLE_DETECTION_CHARTS_V2` (**new with decision #57**), `STRUCT_TREE_RULE_V1`, `STRUCT_TREE_RULE_V2`, `HEADING_INFERENCE_RULE_V4` (**new with decision #29**), `HEADING_INFERENCE_RULE_V5` (**new with decision #47**), `HEADING_INFERENCE_RULE_V6` (**new with decision #50**), `HEADING_INFERENCE_RULE_V7` (**new with decision #64**), `LAYOUT_UNIT_RULE_V1` (**new with decision #38**), `LAYOUT_UNIT_RULE_V2` (**new with line-units-v2**), `LAYOUT_UNIT_RULE_V3` (**new with line-units-v3**), `LAYOUT_UNIT_RULE_V4` (**new with decision #63**), `FURNITURE_RULE_V1` (**new with decision #41**), `FIGURE_RULE_V1` (**new with decision #46**), `RIGHT_TO_LEFT_RULE_V1` (**new with decision #54**), `FORM_ANNOTATION_RULE_V2` |
+| `profile` | `Profile`, `profile_sha256`, `BackendIdentity`, `Capabilities`, `PageBudget`, `XrefRepair`, `VerifierPin`, `TableDetection`, `CMAP_DATA_VERSION`, `READING_ORDER_RULE_V0`, `READING_ORDER_RULE_V1`, `READING_ORDER_RULE_V2`, `READING_ORDER_RULE_V3`, `READING_ORDER_RULE_V4` (**new with decision #32**), `OBSERVATION_RULE_V3`, `OBSERVATION_RULE_V4` (**new with page-observations-v4**), `TEXT_CODE_RULE_V2`, `TEXT_CODE_RULE_V3` (**new with decision #43**), `TEXT_CODE_RULE_V4` (**new with decision #44**), `RasterDpi`, `NOT_RUN`, `DOCX_READING_ORDER_RULE_V2`, `DOCX_TEXT_CODE_RULE_V3`, `XLSX_READING_ORDER_RULE_V1`, `XLSX_TEXT_CODE_RULE_V3`, `PPTX_READING_ORDER_RULE_V1`, `PPTX_TEXT_CODE_RULE_V3`, `ODT_READING_ORDER_RULE_V1`, `ODT_TEXT_CODE_RULE_V2`, `ODS_READING_ORDER_RULE_V1`, `ODS_TEXT_CODE_RULE_V2`, `ODP_READING_ORDER_RULE_V1`, `ODP_TEXT_CODE_RULE_V2`, `RTF_READING_ORDER_RULE_V1`, `RTF_TEXT_CODE_RULE_V2`, `EPUB_READING_ORDER_RULE_V1`, `EPUB_TEXT_CODE_RULE_V2`, `TABLE_DETECTION_V1`, `TABLE_DETECTION_V2`, `TABLE_DETECTION_V3`, `TABLE_DETECTION_V4`, `TABLE_DETECTION_V5`, `TABLE_DETECTION_V6`, `TABLE_DETECTION_V7` (**new with ruled-rects-v7**), `TABLE_DETECTION_V8` (**new with ruled-rects-v8**), `TABLE_DETECTION_V9` (**new with ruled-rects-v9**), `TABLE_DETECTION_V10` (**new with ruled-rects-v10**), `TABLE_DETECTION_V11` (**new with ruled-rects-v11**), `TABLE_DETECTION_V12` (**new with ruled-rects-v12**), `TABLE_DETECTION_UNRULED_V1`, `TABLE_DETECTION_STROKE_V1`, `TABLE_DETECTION_TAGGED_V1`, `TABLE_DETECTION_TRACKS_V3`, `TABLE_DETECTION_TRACKS_V4` (**new with whitespace-tracks-v4**), `TABLE_DETECTION_TRACKS_V5` (**new with whitespace-tracks-v5**), `TABLE_DETECTION_TRACKS_V6` (**new with whitespace-tracks-v6**), `TABLE_DETECTION_TRACKS_V7` (**new with decision #49**), `TABLE_DETECTION_TRACKS_V8` (**new with decision #51**), `TABLE_DETECTION_TRACKS_V9` (**new with decision #52**), `TABLE_DETECTION_TRACKS_V10` (**new with decision #53**), `TABLE_DETECTION_TRACKS_V11` (**new with decision #55**), `TABLE_DETECTION_TRACKS_V12` (**new with decision #56**), `TABLE_DETECTION_TRACKS_V13` (**new with decision #58**), `TABLE_DETECTION_TRACKS_V14` (**new with decision #60**), `TABLE_DETECTION_CHARTS_V1` (**new with decision #42**), `TABLE_DETECTION_CHARTS_V2` (**new with decision #57**), `TABLE_DETECTION_CHARTS_V3` (**new with decision #66**), `TABLE_DETECTION_LINES_V1` (**new with decision #66**), `STRUCT_TREE_RULE_V1`, `STRUCT_TREE_RULE_V2`, `HEADING_INFERENCE_RULE_V4` (**new with decision #29**), `HEADING_INFERENCE_RULE_V5` (**new with decision #47**), `HEADING_INFERENCE_RULE_V6` (**new with decision #50**), `HEADING_INFERENCE_RULE_V7` (**new with decision #64**), `LAYOUT_UNIT_RULE_V1` (**new with decision #38**), `LAYOUT_UNIT_RULE_V2` (**new with line-units-v2**), `LAYOUT_UNIT_RULE_V3` (**new with line-units-v3**), `LAYOUT_UNIT_RULE_V4` (**new with decision #63**), `LAYOUT_UNIT_RULE_V5` (**new with decision #67**), `FURNITURE_RULE_V1` (**new with decision #41**), `FIGURE_RULE_V1` (**new with decision #46**), `RIGHT_TO_LEFT_RULE_V1` (**new with decision #54**), `FORM_ANNOTATION_RULE_V2` |
 | `derivation` | `DerivationClass`, `GeometryPresence`, `GeometryAbsence` |
 | `assurance` | `Assurance`, `Limitation`, `LimitationScope`, `PageState`, `PageStateEntry`, `CoverageSummary`, `ProcessingGaps`, `ProcessingTerminalState`, `RefusalCode`, `PageBindingResult`, `page_binding_status`, `codes` |
 | `representation` | `DocumentRepresentation`, `RepresentationPayload`, `Node`, `NodeKind`, `NodeGeometry`, `PageRecord`, `NativeLocator`, `PdfLocator`, `DocxLocator`, `XlsxLocator`, `PptxLocator`, `OdtLocator`, `OdsLocator`, `OdpLocator`, `RtfLocator`, `EpubLocator`, `PdfObjectLocator`, `StructuralLocator`, `PdfTaggedLocator`, `PdfArtifactLocator`, `AnnotationRect`, `NodeAttributes`, `OfficeRunAttributes`, `OfficeCellAttributes`, `OfficeSlideRunAttributes`, `OfficeParagraphAttributes`, `OdfBlockKind`, `OfficeOdfCellAttributes`, `OfficeOdfShapeAttributes`, `RtfParagraphAttributes`, `RtfParagraphBreak`, `EpubBlockAttributes`, `OdfValueType`, `OdfCellTextSource`, `CellValueType`, `CellTextSource`, `FormFieldAttributes`, `AnnotationAttributes`, `FieldValue`, `SourceIdentity`, `ProcessingRun`, `ProcessorIdentity`, `SynthesizedAt`, `TextRunAttributes`, `Script` (**new with decision #40**), `Furniture` (**new with decision #41**), `Reading` (**new with decision #54**: a run's text as read, beside the order the page drew; `Node::reading_text` returns it where a run carries one and the text elsewhere), `TextFinding`, `PdfImageLocator`, `PaintedRect`, `ImageAttributes`, `ImageMediaType`, `REPRESENTATION_ARTIFACT_TYPE`, `REPRESENTATION_SCHEMA_VERSION` |
diff --git a/docs/draft-schemas/document-representation.draft.json b/docs/draft-schemas/document-representation.draft.json
index 5547798..a2c5530 100644
--- a/docs/draft-schemas/document-representation.draft.json
+++ b/docs/draft-schemas/document-representation.draft.json
@@ -408,7 +408,7 @@
         },
         "region": { "type": "integer", "minimum": 1, "$comment": "D4-S2. Which region of its page the reading-order cut placed this run in, 1-based, in reading order. WHERE text sits, never WHAT it is: not a paragraph, a heading or a column name, and no role may be read from it (P14 — roles come from the structure tree or from nowhere). ABSENT means the cut made no division, which is not the same claim as 'single column'; the profile's reading_order_rule says which rule ran, and under `single-column-v1` no cut runs at all. Absent on almost every page, which is why it is omitted rather than emitted as null." },
         "block": { "type": "integer", "minimum": 1, "$comment": "Which block of its page the leading-gap cut placed this run in, 1-based, in reading order. Emitted under reading_order_rule `gutter-columns-v3` and `gutter-columns-v4`, and absent under every earlier id. WHERE text sits, never WHAT it is: a block is a stretch separated from its neighbours by vertical whitespace wider than its band's own leading, and it is NOT a paragraph, a heading, a list item or a section. No role may be read from it (P14 — roles come from the structure tree or from nowhere), and doc 19 §6 permits this field only as an unnamed Computed index. IT IS NOT A PARAGRAPH INDEX, AND THE MEASUREMENT SAYS SO: on the one gate document able to carry a real paragraph label the rule finds 63.7% of real breaks at 100% precision — it never fires mid-paragraph across 719 chances, and it misses better than a third of the breaks, because 35.1% of real breaks carry no extra leading for any gap rule to see. ABSENT means the rule declined, and unlike region that is the ORDINARY case: a page of uniform body text has no gap wide enough to open a second block and is supposed to have none. Absent also covers a band whose modal gap is a table-column interleave pitch rather than a leading, a band whose gaps are a scatter with no mode, and a format with no cut." },
-        "layout_unit": { "type": "integer", "minimum": 1, "$comment": "Decision #38. Which layout unit of its page the profile's layout_unit_rule joined this run's line into, 1-based in reading order: consecutive lines set no more than half a line apart, overlapping across, of one kind (body text, or an inferred heading of one level), the next opening no list marker; under `line-units-v2` cut where a piece of the line (its runs, cut at gaps wider than its height) follows one that ends short — more than ten of its heights left of the unit's widest piece — so a line's label and value can be two units; and under `line-units-v3` cut before a body line whose first word would have fit twice over after the line above, so a contents list set without markers is a unit per entry. WHERE, NEVER WHAT, as block is: a unit is not the author's paragraph and no role is read from it. ABSENT on a document that declares author structure, on a table's runs and an /Artifact's, on a whitespace-only line, and under every other rule id. Since `line-units-v4` a script (a subscript, a superscript, a footnote mark) on a baseline of its own is part of the line it is set in." },
+        "layout_unit": { "type": "integer", "minimum": 1, "$comment": "Decision #38. Which layout unit of its page the profile's layout_unit_rule joined this run's line into, 1-based in reading order: consecutive lines set no more than half a line apart, overlapping across, of one kind (body text, or an inferred heading of one level), the next opening no list marker; under `line-units-v2` cut where a piece of the line (its runs, cut at gaps wider than its height) follows one that ends short — more than ten of its heights left of the unit's widest piece — so a line's label and value can be two units; and under `line-units-v3` cut before a body line whose first word would have fit twice over after the line above, so a contents list set without markers is a unit per entry. WHERE, NEVER WHAT, as block is: a unit is not the author's paragraph and no role is read from it. ABSENT on a document that declares author structure, on a table's runs and an /Artifact's, on a whitespace-only line, and under every other rule id. Since `line-units-v4` a script (a subscript, a superscript, a footnote mark) on a baseline of its own is part of the line it is set in. Since `line-units-v5` a line is the pieces of one baseline that follow each other in reading order, so a baseline running across columns the reading order reads apart is a line per column, and a line's text has a space where its words stand apart with none drawn, so a bullet set apart by its position opens a list item." },
         "inferred_heading": { "type": "boolean", "const": true, "$comment": "Decision #29. Set where the profile's heading_inference_rule read this run's line as a heading from the TYPE THE PAGE DRAWS, on a document that declares no /StructTreeRoot. Computed, never the author's: the rule id names the rule, and the artifact declares headings-inferred-from-type with the line count and the body reference in centipoints it measured. ABSENT WHERE FALSE — hence `const: true` — so a run the rule did not touch serializes exactly as it did before the rule existed, and a tagged document's artifact differs only by the profile hash. A verdict and not a measurement: the rendered em it was read from exists only inside the PDF reader, and is not on the wire. Only a text run can carry it, so no office node can acquire an inferred heading by accident." },
         "inferred_heading_level": { "type": "integer", "minimum": 2, "maximum": 7, "$comment": "Decision #38. The level `type-size-v3` gave an inferred heading, where it is deeper than 1: the sizes a document's inferred headings are set in, largest first, are levels 1 to 6, and a bold line standing apart is the level below the smallest. Computed, as inferred_heading is, and only beside it. ABSENT AT LEVEL 1 and on every run that is no inferred heading, so a document whose headings share one size serializes as it did under `type-size-v2`. Since `type-size-v5` (decision #47) 7 is a LABEL: a bold line at the head of its text that does not stand apart, below every ranked level, which both projections write as a bold line and never with #." },
         "bold": { "type": "boolean", "const": true, "$comment": "Decision #38. Set where the font that drew this run declares itself bold — a /FontWeight of 600 or more, the ForceBold flag, or a bold style word in its /BaseFont — and under `page-observations-v4` where the TrueType or OpenType program it embeds states a weight class of 600 or more (or, with no OS/2 table, head's macStyle bold bit), or where the run is painted fill-then-stroke (text rendering mode 2 or 6). A statement about the typeface and its painting, rendered as strong emphasis by the projections. PDF only. Absent where false." },
@@ -621,7 +621,7 @@
         "columns": { "type": "integer", "minimum": 0 },
         "cells": { "type": "array", "items": { "$ref": "#/$defs/table_cell_record" } },
         "derivation": { "$ref": "urn:ethos-parser:draft-schema:derivation-class:0", "$comment": "`computed` for a grid this engine reconstructed from ink or alignment, `extracted` for one the structure tree declares." },
-        "detection_rule": { "type": "string", "examples": ["ruled-rects-v8", "unruled-align-v1", "stroke-ruled-v1", "tagged-tables-v1", "whitespace-tracks-v14", "bar-labels-v2"], "$comment": "The rule that produced this table, from profile.table_detection." },
+        "detection_rule": { "type": "string", "examples": ["ruled-rects-v8", "unruled-align-v1", "stroke-ruled-v1", "tagged-tables-v1", "whitespace-tracks-v14", "bar-labels-v3", "point-labels-v1"], "$comment": "The rule that produced this table, from profile.table_detection." },
         "locator_check": {
           "$ref": "#/$defs/locator_check",
           "$comment": "The structural and geometric cross-check of the cells against the grid."
diff --git a/docs/draft-schemas/profile.draft.json b/docs/draft-schemas/profile.draft.json
index 6f92ebb..b3d2327 100644
--- a/docs/draft-schemas/profile.draft.json
+++ b/docs/draft-schemas/profile.draft.json
@@ -212,9 +212,10 @@
         "stroke_ruled",
         "tagged",
         "tracks",
-        "charts"
+        "charts",
+        "lines"
       ],
-      "description": "The table-detection rules in force. An object rather than a string since v1-S2, three fields since v1-S8, four since v2-S24, five since decision #38 and six since decision #42: with several rules running, a single id could not say whether a run looked for a kind of table and found none or never looked, and those are different documents to a consumer. Every table on the wire also names the rule that produced it.",
+      "description": "The table-detection rules in force. An object rather than a string since v1-S2, three fields since v1-S8, four since v2-S24, five since decision #38, six since decision #42 and seven since decision #66: with several rules running, a single id could not say whether a run looked for a kind of table and found none or never looked, and those are different documents to a consumer. Every table on the wire also names the rule that produced it.",
       "properties": {
         "ruled": {
           "type": "string",
@@ -238,15 +239,20 @@
         },
         "charts": {
           "type": "string",
-          "description": "Version id of the rule that reads a bar chart's printed labels back as its table (decision #42). `bar-labels-v2`. Bars are rectangles the page filled in a known colour that is not white, a rectangle drawn with its corners named twice among them (decision #57); columns are bars of one width set end to end in colours that differ; a chart is two or more columns on one base, of one width, side by side, its categories each column or each period of repeating colours — where no period holds, each group the gaps between columns set apart, a colour two groups hold a series and a column of another colour the series of its place in a full group; three columns or more each a colour of its own are one series, which takes no title (decision #57). A value is the one number on a bar's segment or just past a single bar's end, a number two cells could read filling neither; a category the one label at the column's base, with the lines it wraps onto, never a number but a year, a label opening with a value, a line of prose or a label set on a bar; a series' name the one label beside a legend swatch of its colour near the chart and the labels it read and nearer it than other bars of that colour, or a one-colour chart's one-line title. A table only where the numbers agree with the bars in order and six bars in ten of a series carry one, no label read twice and no run in two tables; a value is never read off a bar's length and an empty cell is not emitted. Runs after `tracks`, on runs no other rule's table holds, only on a document that declares no author structure; a cell holds only its label's runs."
+          "description": "Version id of the rule that reads a bar chart's printed labels back as its table (decision #42). `bar-labels-v3`. Bars are rectangles the page filled in a known colour that is not white, a rectangle drawn with its corners named twice among them (decision #57); columns are bars of one width set end to end in colours that differ; a chart is two or more columns on one base, of one width, side by side, its categories each column or each period of repeating colours — where no period holds, each group the gaps between columns set apart, a colour two groups hold a series and a column of another colour the series of its place in a full group; three columns or more each a colour of its own are one series, which takes no title (decision #57). A value is the one number on a bar's segment or just past a single bar's end, a number two cells could read filling neither; a category the one label at the column's base, with the lines it wraps onto, never a number but a year, a label opening with a value, a line of prose or a label set on a bar; a series' name the one label beside a legend swatch of its colour near the chart and the labels it read and nearer it than other bars of that colour, or a one-colour chart's one-line title — since `bar-labels-v3` (decision #66), the one series that prints numbers, whatever else is drawn beside it. A table only where the numbers agree with the bars in order and six bars in ten of a series carry one, no label read twice and no run in two tables; a value is never read off a bar's length and an empty cell is not emitted. Runs after `tracks`, on runs no other rule's table holds, only on a document that declares no author structure; a cell holds only its label's runs."
+        },
+        "lines": {
+          "type": "string",
+          "description": "Version id of the rule that reads the numbers a line chart prints at its points back as its table (decision #66). `point-labels-v1`. A series is a line the page stroked whose every point stands right of the one before, not all at one height — a line drawn twice read once — or three or more small marks of one colour and size so set; a line drawn through a run of marks is that run. Each number goes to the one point it is set over, under or beside, unless another series' point stands nearly as near (within one and a half times the distance), and each point keeps its nearest number; a number set on a bar is the bar's. A series keeps its numbers where six points in ten carry one and a point higher on the page never carries a smaller number; its categories are the first row of labels below the plot holding one label under eight points in ten, no label twice and at most half of them numbers but years. Series reading one row are one table, each named by the block of lines beside a legend swatch of its colour — a small mark or a short level stroke — or a lone series by the one-line title over it. A value is never read off a point's height and an empty cell is not emitted. Runs after `charts`, on runs no other rule's table holds, only on a document that declares no author structure."
         }
       }
     },
     "layout_unit_rule": {
       "type": "string",
       "minLength": 1,
-      "description": "Version id of the layout-unit rule in force (decision #38). `line-units-v2`: on a document that declares no author structure, each page's lines are read in reading order and a line joins the unit above it when its box sits no more than half its own height below that unit's, overlaps it across at least half the narrower width, is the same kind (body text, or an inferred heading of the same level) and opens with no list marker; then each line is read as its pieces (its runs, cut wherever the gap between two is wider than the line's height), and the pieces of one unit that follow each other in reading order are cut before a piece when the piece before it ends more than ten of the piece's heights left of their widest piece's right edge. `line-units-v3` then cuts a unit of body text before a line whose first word, with its space, would have fit twice over between where the line above ends and the unit's widest piece's right edge — a break its author made, not its measure; a heading unit is not cut. `line-units-v4` (decision #63) first joins to the line before it in reading order a line set under seventeen twentieths of its height, its baseline within half that line's height, inside that line's extent past its start: a subscript, a superscript or a footnote mark on a baseline of its own. The unit's 1-based ordinal travels as text_run.layout_unit. Where, never what: a unit is not the author's paragraph. `not-run-for-this-format` on every office profile. A profile with no such key is REFUSED rather than defaulted.",
+      "description": "Version id of the layout-unit rule in force (decision #38). `line-units-v2`: on a document that declares no author structure, each page's lines are read in reading order and a line joins the unit above it when its box sits no more than half its own height below that unit's, overlaps it across at least half the narrower width, is the same kind (body text, or an inferred heading of the same level) and opens with no list marker; then each line is read as its pieces (its runs, cut wherever the gap between two is wider than the line's height), and the pieces of one unit that follow each other in reading order are cut before a piece when the piece before it ends more than ten of the piece's heights left of their widest piece's right edge. `line-units-v3` then cuts a unit of body text before a line whose first word, with its space, would have fit twice over between where the line above ends and the unit's widest piece's right edge — a break its author made, not its measure; a heading unit is not cut. `line-units-v4` (decision #63) first joins to the line before it in reading order a line set under seventeen twentieths of its height, its baseline within half that line's height, inside that line's extent past its start: a subscript, a superscript or a footnote mark on a baseline of its own. `line-units-v5` (decision #67) cuts each line into its pieces before any unit is read and reads as a line the pieces of one line that follow each other in reading order, so a baseline running across columns the reading order reads apart is a line per column; and the text the list-marker clause and the first word are read from has a space wherever two runs' boxes stand a tenth of the line's height apart or more, a word gap the page set by moving its pen. The unit's 1-based ordinal travels as text_run.layout_unit. Where, never what: a unit is not the author's paragraph. `not-run-for-this-format` on every office profile. A profile with no such key is REFUSED rather than defaulted.",
       "examples": [
+        "line-units-v5",
         "line-units-v4",
         "line-units-v3",
         "line-units-v2"
@@ -505,7 +511,7 @@
       "form_annotation_rule": "form-annotations-v2",
       "furniture_rule": "margin-bands-v1",
       "heading_inference_rule": "type-size-v7",
-      "layout_unit_rule": "line-units-v4",
+      "layout_unit_rule": "line-units-v5",
       "html_rule": "html-blocks-v12",
       "locate_rule": "locate-scalar-exact-v1",
       "markdown_rule": "markdown-blocks-v12",
@@ -523,7 +529,8 @@
       "right_to_left_rule": "right-to-left-lines-v1",
       "struct_tree_rule": "struct-tree-v2",
       "table_detection": {
-        "charts": "bar-labels-v2",
+        "charts": "bar-labels-v3",
+        "lines": "point-labels-v1",
         "ruled": "ruled-rects-v12",
         "stroke_ruled": "stroke-ruled-v1",
         "tagged": "tagged-tables-v1",
diff --git a/docs/measurements/parsebench/README.md b/docs/measurements/parsebench/README.md
index 1a6b413..8ec9791 100644
--- a/docs/measurements/parsebench/README.md
+++ b/docs/measurements/parsebench/README.md
@@ -788,6 +788,41 @@ columns' headings, folios, column headers and twice-drawn text); headings inferr
 documents that declare none (formatting 0.4573, content down on 15 pages — the owner's call, since
 it changes documents that declare structure).
 
+### After a line chart's printed values (`point-labels-v1`, `bar-labels-v3`, decision #66, 2026-10-13)
+
+Told "Charts, round 3", the chart points that print their value and fail were read for why: 284 of
+846 on pages whose bars the bar rule never found, 328 on pages whose bars it refused, 234 on pages
+whose table missed them, each reason small; the largest coherent piece was a line chart printing a
+number at each point. `point-labels-v1` reads one (`docs/32-CHART-LABELS-SCOPE.md` §9), and
+`bar-labels-v3` names a progress bar's one numbered series by the title over it (§8). Charts
+0.1184 -> 0.1248, 7 pages up and none down; every other dimension unchanged on every page;
+opendataloader-bench NID 0.8841 -> 0.8838 and TEDS 0.5339 -> 0.5301 on one document whose line reads
+right as a table (the owner took the trade). Overall 46.29 -> 46.42. Round 1's line prototype,
+re-run here, measured 0.1192: it judged each series alone and so lost the numbers of lines running
+close, and refused a tenor row's `3M` as a number.
+
+### After a line read where the reading order reads it (`line-units-v5`, decision #67, 2026-10-13)
+
+Told "Grounding: text, round 2", the `Text` elements visual grounding could not place were counted
+again by how our items sit on them: split across several of ours 811 (0.051 of the score), nothing
+of ours over them 520 (0.032 — pages drawn as images, figure regions, panels read as ruled tables),
+one item of ours far bigger 483 (0.023), ours covering under half 182 (0.015). The largest split
+was a page the reading order did not divide, where a line was every run on its baseline across the
+page: a newspaper paragraph sharing its baselines with a byline in the next column was read where
+the byline was, and fell into five units. `line-units-v5` reads as a line the pieces of one line
+that follow each other in reading order, and reads a space where two runs stand a tenth of the
+line's height apart, so a bullet set apart by its position opens an item and a first word is a word
+on pages that set their words by moving the pen. Visual grounding 0.5435 -> 0.5575, 119 pages up
+and 8 down (the owner took the trade); content one page up by 0.0003; every other dimension
+unchanged on every page; opendataloader-bench and the gate documents' tables unchanged. Overall
+46.42 -> 46.70. The split bucket fell 811 -> 646 with the lines alone. Measured on the way: the
+lines alone 0.5546 (109 up, 12 down — the falls were cuts the across-columns edge made by
+accident); with the bullets 0.5561; the space read for the first word too, at a quarter of the
+line's height 0.5564, at a tenth 0.5575, at a twentieth 0.5577 (2 pages up and 2 down against a
+tenth, so the tenth stands). Left as found: newspaper pages whose columns the stream draws row by
+row (the reading order reads across them), and Markdown that writes such a page one word per
+block — 71 content pages are mostly one-word blocks.
+
 ### Ethos + OCR pass (decision #45, 2026-10-05)
 
 Under `ETHOS_BENCH_OCR=1` the adapter reads scans through Tesseract outside the engine (English