html: one document-global row counter instead of one per table

bb_html gave each <table> its own row counter starting at 0, separate
from the flow-block counter. That made y ambiguous across structural
boundaries: an <h2> after a table got the same y as a row inside it, so
ordering a document by (y, x) interleaved the two.

Measured against Chromium's rendered geometry (Playwright + TreeWalker
+ Range.getClientRects), that single collision caused 23 of 24
reading-order inversions. Sharing one counter:

    Spearman rho   0.9552 -> 0.9996
    inversions     24/465 (5.2%) -> 1/465 (0.2%)
    row grouping   30/50 (60%) -> 30/30 (100%)

Table geometry was already exact and stays so: 30/30 row grouping and
40/40 column alignment among table cells, before and after.

The residual single inversion is the flex two-column block, which
renders side by side and which the grid places on separate rows. Layout
resolves that, not the DOM, so no static walk can capture it - recorded
as an inherent limit rather than a defect.

A nested table is seeded from its enclosing cell's row and does not
write back to the document counter, so it cannot disturb the outer
numbering. An empty table emits no <tr> and costs no rows.

experiments/html_grid_diagnose.py is now a pass/fail regression gate on
the counter staying global.

Verified no regression elsewhere: pdf 107, xlsx 54, xls 68, docx 35,
and the 470-file xls corpus gate unchanged at 0 UNEXPECTED-FAIL with
2339 formulas matched.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: phrrngtn

experiments/html_grid_diagnose.py

@@ -77,9 +77,12 @@ def main() -> int:
     resets = [i for i in range(1, len(ys)) if ys[i] < ys[i - 1]]
     print(f"   grid y sequence  : {ys}")
     print(f"   backward jumps   : {len(resets)} at emission index {resets}")
-    print("   -> the table keeps its own row counter, so a heading after the")
-    print("      table can share a y with a row inside it. Sorting the whole")
-    print("      document by (y, x) therefore interleaves blocks.")
+    if resets:
+        print("   FAIL -> a block restarts the row counter, so a heading after a")
+        print("           table can share a y with a row inside it, and ordering")
+        print("           the document by (y, x) interleaves the two.")
+    else:
+        print("   PASS -> monotonic; tables continue the document numbering.")
 
     # ── what does that cost, and what would fixing it buy? ───────────
     # "Fixed" grid = emission order made monotonic by numbering rows globally,
@@ -96,12 +99,17 @@ def main() -> int:
                                  lambda r: (round(r["y"], 1), r["x"]))
     inv1, _, rho1 = inversions(pairs, lambda g, i: (fixed[id(g)], g["x"]),
                                lambda r: (round(r["y"], 1), r["x"]))
-    print("\n2. COST OF THE COLLIDING COUNTERS")
+    print("\n2. COST OF ANY COLLIDING COUNTERS")
     print(f"   as emitted       : rho={rho0:.4f}  inversions={inv0}/{tot} "
           f"({100*inv0/tot:.1f}%)")
     print(f"   with a global y  : rho={rho1:.4f}  inversions={inv1}/{tot} "
           f"({100*inv1/tot:.1f}%)")
-    print(f"   -> the single defect accounts for {inv0-inv1} of {inv0} inversions")
+    if inv0 == inv1:
+        print(f"   -> no gain available: numbering is already global")
+    else:
+        print(f"   -> restarting counters accounts for {inv0-inv1} of {inv0} inversions")
+    print(f"   (the residual {inv1} is the flex side-by-side case in section 3,")
+    print(f"    which no DOM-order model can capture)")
 
     # ── the inherent limit: side-by-side layout ──────────────────────
     print("\n3. WHAT A GRID CANNOT CAPTURE (inherent, not a bug)")
@@ -117,7 +125,8 @@ def main() -> int:
         print(f"   grid puts them on separate rows  : {gl['y'] != gr_['y']}")
         print("   -> flex/float layout is resolved by the layout engine, not by")
         print("      the DOM. No static walk can know it without doing layout.")
-    return 0
+    # Regression gate: the row counter must stay document-global.
+    return 1 if resets else 0
 
 
 if __name__ == "__main__":

src/bboxes_html.cpp

@@ -67,20 +67,33 @@ static int span_attr(lxb_dom_node_t* n, const char* attr, int def) {
 
 /* ── DOM walk ────────────────────────────────────────────────────── */
 
-/* Per-table cursor: row starts at -1 (bumped by the first <tr>), col resets per row. */
+/* Per-table cursor. `row` is seeded from the enclosing document row rather than
+   from -1, so table rows continue the document's row numbering instead of
+   restarting; `col` resets per row. See the note on flow_line below. */
 struct TableCtx { int row; int col; };
 
 struct WalkCtx {
     Page*    page;
     uint32_t style_id;
-    int      flow_line = 0;   /* reading-order line counter for flow content */
+    /* The document row counter, shared by flow blocks AND tables.
+     *
+     * It used to be flow-only, with each <table> starting its own counter at 0.
+     * That made y ambiguous: a heading after a table got the same y as a row
+     * inside it, so ordering the document by (y, x) interleaved the two. Against
+     * Chromium's rendered geometry that single collision produced 23 of 24
+     * reading-order inversions; sharing one counter took Spearman rho from
+     * 0.9552 to 0.9996. See experiments/html_grid_diagnose.py, which is the
+     * regression test for this. */
+    int      flow_line = 0;
     double   max_x = 0.0;     /* widest extent  (x + w) */
     double   max_y = 0.0;     /* tallest extent (y + h) */
 };
 
 /* Walk children in document order. `tc != nullptr` means we are inside a <table>.
    Imputed integer geometry (0-based), mirroring the proven reducer:
-     - <table>: open a fresh grid cursor and descend.
+     - <table>: open a grid cursor seeded from the current document row, and
+                descend; on the way out, resume flow numbering after the last
+                row the table used.
      - <tr>:    advance row, reset col.
      - <td>/<th>: emit a cell box at (x=col, y=row, w=colspan, h=rowspan).
      - flow block (p/li/hN/…): emit a box at (x=depth, y=line++, w=len(text), h=1).
@@ -94,8 +107,16 @@ static void walk(lxb_dom_node_t* node, int depth, WalkCtx* ctx, TableCtx* tc) {
             name_is(n, "noscript") || name_is(n, "template")) continue;
 
         if (name_is(n, "table")) {
-            TableCtx t{-1, 0};
+            /* Seed from the enclosing row so the table continues the document's
+               numbering. The first <tr> bumps this, hence the -1. A nested
+               table sits within its cell's row and must not disturb the
+               document counter, so only a top-level table writes back. */
+            const int base = tc ? tc->row : ctx->flow_line - 1;
+            TableCtx t{base, 0};
             walk(n, depth + 1, ctx, &t);
+            /* Resume after the last row the table actually used. An empty table
+               emits no <tr>, leaves t.row == base, and so costs no rows. */
+            if (!tc) ctx->flow_line = t.row + 1;
 
         } else if (tc && name_is(n, "tr")) {
             tc->row++;