fix(formats): skip full rows before walking them for HTML rowspans

crates/formats/src/model.rs

@@ -58,6 +58,23 @@ mod tests {
         assert!(t.rows.iter().all(|r| r.len() <= 64), "a row grew past the column cap");
     }
 
+    #[test]
+    fn insert_covered_skips_full_rows_without_walking_them() {
+        // 50,000 spanning cells over a 50,000-cell row: each walked the row below to its grid
+        // column before finding it full (billions of steps). A full row is now skipped at once.
+        let n = 50_000;
+        let mut t = FTable {
+            rows: vec![vec![Cell { rowspan: 2, ..Default::default() }; n], vec![Cell::default(); n]],
+            widths: Vec::new(),
+            borderless: false,
+        };
+        let start = std::time::Instant::now();
+        t.insert_covered();
+        assert!(start.elapsed() < std::time::Duration::from_secs(10), "{:?}", start.elapsed());
+        assert_eq!(t.rows[1].len(), n, "a full row takes no covered cell");
+        assert!(t.rows[1].iter().all(|c| !c.covered));
+    }
+
     #[test]
     fn base64_round_trip() {
         for data in [&b""[..], b"f", b"fo", b"foo", b"foob", b"fooba", b"foobar", &[0, 255, 128, 7]] {

crates/formats/src/model/types.rs

@@ -418,6 +418,11 @@ impl FTable {
                             return;
                         }
                         let Some(row) = self.rows.get_mut(r + k) else { break };
+                        // A full row takes no covered cell: checked before it is walked, so a
+                        // wide row isn't scanned for every span above it.
+                        if row.len() >= 64 {
+                            continue;
+                        }
                         // Find the index in that row at grid column `g`.
                         let mut x = 0usize;
                         let mut at = row.len();
@@ -428,9 +433,7 @@ impl FTable {
                             }
                             x += cc.colspan.clamp(1, 63) as usize;
                         }
-                        if row.len() < 64 {
-                            row.insert(at, Cell { colspan: span as u32, covered: true, ..Default::default() });
-                        }
+                        row.insert(at, Cell { colspan: span as u32, covered: true, ..Default::default() });
                     }
                 }
                 g += span;

crates/metafile/src/place.rs

@@ -136,14 +136,8 @@ impl Picture {
             match item {
                 Item::Path { segs, fill, stroke, even_odd } => {
                     let path = tf * bez(segs);
-                    let bounds = path.bounding_box();
-                    if in_range(bounds) {
-                        // A pen wider than twice the distance across the frame and the path
-                        // already covers the whole frame: wider adds nothing the frame shows, only
-                        // work for the renderer flattening its round caps (the width is file data).
-                        let u = bounds.union(r);
-                        let widest = 2.0 * u.width().hypot(u.height());
-                        let stroke = stroke.map(|(c, w)| (c, (f64::from(w) * k).min(widest)));
+                    if in_range(path.bounding_box()) {
+                        let stroke = stroke.map(|(c, w)| (c, f64::from(w) * k));
                         out.push(PlacedItem::Path { path, fill: *fill, stroke, even_odd: *even_odd });
                     }
                 }

crates/metafile/src/tests.rs

@@ -891,34 +891,6 @@ fn place_fits_the_frame_scales_strokes_and_drops_far_paths() {
     assert_eq!(stroke.map(|s| s.1), Some(8.0));
 }
 
-#[test]
-fn a_huge_pen_is_held_to_what_covers_the_frame() {
-    // A pen of 1e30 units on a short path: round caps that wide took the renderer forever to
-    // flatten. Past twice the distance across the frame and the path it covers no more.
-    let path = |w: f32| crate::Picture {
-        width: 100.0,
-        height: 50.0,
-        items: vec![Item::Path {
-            segs: vec![Seg::Move(0.0, 0.0), Seg::Line(10.0, 0.0)],
-            fill: None,
-            stroke: Some(([0, 0, 0, 255], w)),
-            even_odd: true,
-        }],
-    };
-    let width = |w: f32| match pic_place(&path(w)).first() {
-        Some(crate::PlacedItem::Path { stroke, .. }) => stroke.map(|s| s.1),
-        _ => None,
-    };
-    let cap = 2.0 * 200f64.hypot(100.0);
-    assert_eq!(width(1e30), Some(cap));
-    assert_eq!(width(f32::MAX), Some(cap));
-    assert_eq!(width(4.0), Some(8.0), "an ordinary pen is untouched");
-}
-
-fn pic_place(pic: &crate::Picture) -> Vec<crate::PlacedItem> {
-    pic.place(kurbo::Rect::new(0.0, 0.0, 200.0, 100.0), [0.0; 4])
-}
-
 /// #1899: a crop keeps what the file says down to a sliver (a header's bar is 2.7% of a page-sized
 /// metafile), and junk sides give a finite part of the source with some area.
 #[test]