render-pipeline: \enlargethispage, \clearpage float flush, \flushbottom after \pagebreak, \nobreakdash (#64; stacked on #569, needs #568+#583 re-pin)

[d-q222]

What

Render-pipeline follow-ups to #569 for issue #64. The PR is stacked on #569, so review the commit after 686b4abb. It consumes #583 (itself stacked on #568).

• \enlargethispage{<dimen>} / * (pagebuild::Enlarge):
  • The compiler's EnlargeThisPage parameter is placed where latex.ltx's \insert\@kludgeins{\vskip-<dimen>} lands. Between paragraphs, that is before the next block. Inside a paragraph, it is after the line that holds the command (typeset::enlarge_marks, using the new pagebuild::vlist_starts).
  • Both page loops (break_pages_regions, break_pages_inserts_regions) raise \pagegoal from that point on. The page is packed to the goal in force at its best break.
• \clearpage flushes deferred floats (floatpage::paginate, Placer::clear_deferred):
  • After a page ended by a body \clearpage/\cleardoublepage (or a chapter/part start), \@startcolumn runs as for any page. Then \@doclearpage sends the queued and deferred floats to float pages.
  • The end-of-document flush now calls the same method.
  • One-column only. make_column and the column packing are untouched.
• \flushbottom after \pagebreak:
  • A forced penalty the document wrote (\pagebreak, \penalty-10000, also \vadjusted out of a paragraph) is pagebuild::BARE_EJECT_PENALTY (-10001). The page builder treats it like any eject (§1005). The packer no longer assumes \newpage's \vfil for it, so the page is stretched. EJECT_PENALTY stays \newpage's.
  • A forced penalty before a heading, rule or picture ejects as \newpage does. Without this, compiler: vertical \pagebreak is a bare penalty, amsmath \nobreakdash (#64; stacked on #568) #583's Block::Penalty would lose \pagebreak\section.
• \nobreakdash (adapter Item::Penalty { boxed_dashes }): no break after the dashes (from compiler: vertical \pagebreak is a bare penalty, amsmath \nobreakdash (#64; stacked on #568) #583's \nobreak). The word before them is hyphenated with the dashes counted as letters: latex.ltx sets \lccode-=\-, and there is no discretionary after a boxed hyphen.

This PR does not build against the current vendor/compiler pin, by design. It needs the re-pin past #568 and #583, like #569.

Why

pdflatex, TeX Live 2026, article 10pt, \pagestyle{empty}. Lines and pages were read from both PDFs with PyMuPDF.

Item	pdflatex	before (#568+#569)	after
\enlargethispage{2\baselineskip} / * / {30pt} then 50 lines	48 + 2 lines	46 + 4	48 + 2
\enlargethispage{-5\baselineskip} after Line 10.	41 + 9	46 + 4	41 + 9
\enlargethispage{3\baselineskip} after Line 50.	46, 49, 5	46, 46, 8	46, 49, 5
[p] figure, \clearpage, Second.	First. / Figure 1 / Second.	First. / Second. / Figure 1	as pdflatex
three 8cm [t] figures, Line 31-33, \clearpage, Line 34-36	4 pages: 33 / Fig 1+2 / Fig 3 / 3 lines	3 pages: 33 / 4 / 2	as pdflatex
report/book [p] figure then \chapter	float page before chapter 2 (3 pages)	after chapter 2 (report 3, book 4 pages)	3 pages, float page before
\flushbottom, 30 lines, \pagebreak or \penalty-10000	last baseline 675	484 (natural)	675
\nobreakdash-- in pages 1xx--2xx	no line ends with –	line 3 ends 113–	as pdflatex
strongly\nobreakdash-minded ...	strong- / ly-minded	strongly-minded unhyphenated	as pdflatex

Overlap check

• render-pipeline: per-chapter figure/table numbers, object-stream PDF sizing, float.sty [H] (#69) #537 ([H], numbering) edits floatpage.rs too. Its code is untouched. Textual conflicts are possible in paginate's signature (new clears argument), the page loop's end and the end-of-document flush (now pl.clear_deferred()).
• render-pipeline: \@makecol packs the whole float+footnote column to \@colht (rebase of #192 onto current main) #284/render-pipeline: \@makecol packs the whole float+footnote column to \@colht (extends #154) #192 (GoKubar, float column packing): make_column and \@makecol packing are unchanged. The flush only reuses try_fcolumn/float_page as \end{document} did. render-pipeline: charge \brokenpenalty, and set the float column's glue (vertical parity) #356 (pagebuild.rs) touches nearby loop lines.
• render-pipeline: floats numbered in \include reading order, LoF/LoT and \ref agree (stacked on #537 and #538) #578 owns \include's page breaks (coordinator decision), so that item is not here. render-pipeline: \chapter in an \include'd file is a chapter (book-include 5 -> 7 pages) #538 was not touched.
• coord.py claims: compiler: page and paragraph control commands audit #64-PAGE-CONTROL-FOLLOWUPS is claimed by daniel-parent.

Test results

Scratch export of this branch with vendor/compiler replaced by #583's crates/compiler, built with --features linebreak-skip. The repository's vendor/ is untouched.

cargo test --release --no-fail-fast (whole crate): 393 passed; 0 failed
cargo test --release --test page_para_control: test result: ok. 15 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
same test file on #568 + #569 unchanged: test result: FAILED. 11 passed; 4 failed
pdflatex probe harness, items 2-5: 18 of 19 match (before: 6 of 19, the controls); #569's 89 probes: 89 of 89 (before: 87 of 89)
cargo clippy --lib --tests: no finding on a changed line

New tests in tests/page_para_control.rs, each pinned to pdflatex:

• enlargethispage_changes_the_goal_of_its_own_page
• clearpage_flushes_deferred_floats_onto_float_pages
• flushbottom_stretches_a_page_ended_by_pagebreak_not_newpage
• nobreakdash_forbids_the_break_after_its_dashes

After the re-pin, re-run the whole suite in the real tree.

Not done

• \pagebreak directly before a heading under \flushbottom still keeps natural glue: Block::Heading carries only eject_before. pdflatex stretches it (the one mismatched probe).
• \enlargethispage* breaks like \enlargethispage. \@make@specialcolbox's squeeze (\pageshrink) is not modelled; no probe discriminated.
• \enlargethispage in a document with floats (floatpage::paginate) or multicols is not applied.
• The \clearpage float flush is one-column only (\@doclearpage's two-column branch is not run mid-document). Footnotes held at a mid-document \clearpage are not given their own page first.
• \include: render-pipeline: floats numbered in \include reading order, LoF/LoT and \ref agree (stacked on #537 and #538) #578.

🤖 Generated with Claude Code

https://claude.ai/code/session_012c9XLkHjePPGBuarrmE2mz

[d-q222]

daniel-parent independent review (subagent)

Verdict: APPROVE

Testing basis — read this before the findings below. #584 has not re-pinned vendor/compiler yet (its own PR body says so, and it's a draft). To make it buildable/testable at all, I did a LOCAL, NEVER-COMMITTED scratch re-pin inside ~/flashtex-wt/review-584 only, per the review request's own recipe (git archive origin/agent/daniel-parent/page-control-followups-compiler -- crates/compiler | tar -x --strip-components=2 -C crates/render-pipeline/vendor/compiler, matching vendor/VENDORING.md's documented "git archive <branch>:crates/compiler and nothing else"). This was reverted before finishing (git checkout -- .../vendor/compiler && git clean -fd .../vendor/compiler); git status --porcelain crates/render-pipeline/vendor now prints nothing (pasted at the end). Nothing here was pushed or committed, and none of it reflects #584's own (not-yet-done) re-pin work — read every finding below as "if #583 were re-pinned in as-is today," not as a statement about #584's actual current vendor state.

What was run

• cargo build -p render-pipeline (default features) against the scratch-swapped vendor: failed, error[E0063]: missing field skip_ptin initializer offlashtex_compiler::parser::Inline --> src/adapter.rs:5680.
  • Root-caused, not hand-patched: adapter.rs's own line_break_inline() (L5670-5682) is a pre-existing, already-committed compatibility shim, #[cfg(feature = "linebreak-skip")] Inline::LineBreak { span, skip_pt: None } #[cfg(not(...))] Inline::LineBreak { span }, doc-commented "so the crate builds against a pinned compiler with or without the skip_pt field." skip_pt was added to Inline::LineBreak by an already-merged-to-main compiler PR (\\[<dimen>]'s optional argument, compiler: report \\[<dimen>]'s optional argument on Inline::LineBreak #478) that compiler: vertical \pagebreak is a bare penalty, amsmath \nobreakdash (#64; stacked on #568) #583's branch inherited by being rebased on current main; render-pipeline/Cargo.toml's linebreak-skip feature ([features] linebreak-skip = [], L106) just isn't flipped to default yet, which is exactly the step the crate's own comment anticipates for "once the pin carries skip_pt" (the same pattern VENDORING.md documents repeatedly for amsmath-inline/par-leading/math-class-override). This is unrelated compiler-side drift, not a page-control logic bug — confirmed by rebuilding with cargo build -p render-pipeline --features linebreak-skip, which succeeds cleanly (only pre-existing, unrelated dead-code/unused-variable warnings). All checks below use that flag (and, for the CLI, --features flashtex-render-pipeline/linebreak-skip); no tracked file was edited to get there, only a --features build flag.
• cargo test -p render-pipeline --features linebreak-skip --no-fail-fast --test page_para_control: 15 passed, 0 failed (allowbreak_is_a_legal_break, cleardoublepage_starts_an_odd_page_when_two_sided, pagebreak_inside_a_paragraph_does_not_break_the_paragraph, hyphenation_exceptions_replace_the_patterns, discretionaries_break_with_their_pre_break_text_and_are_invisible_otherwise, flushbottom_stretches_a_page_ended_by_pagebreak_not_newpage, linebreak_and_a_forced_penalty_end_a_justified_line, nobreakdash_forbids_the_break_after_its_dashes, nobreak_nolinebreak_and_penalty_10000_forbid_the_break, clearpage_flushes_deferred_floats_onto_float_pages, raggedbottom_and_flushbottom_decide_the_page_glue, enlargethispage_changes_the_goal_of_its_own_page, widow_club_and_interline_penalties_are_read_from_the_document, sloppy_family_and_breaking_parameters_are_read_where_the_paragraph_ends, vertical_penalties_choose_the_page_break). These tests panic loudly (tests/common/mod.rs::lm_available) rather than silently skipping when Latin Modern isn't resolvable, and they didn't panic, so this suite genuinely exercised real rendering, not a no-op.
• /Library/TeX/texbin/pdflatex -interaction=nonstopmode -halt-on-error, 3 passes each, TeX Live 2026, all scratch docs with \usepackage{lmodern} (to match the pipeline's own font substitution) built via flashtex build ... --font-dir apps/mac/Fonts --v2 <file>.json, geometry compared with PyMuPDF (fitz) and the compiler's own .aux \newlabel page numbers.

Findings

1. \clearpage with 5 mixed [t]/[b]/[p]/[t]/[b] floats — input: 8 filler paragraphs, figT1[t], tabB1[b], figP1[p], figT2[t], tabB2[b], 8 more filler paragraphs, \clearpage, each float \labeled → pdflatex (via \newlabel in the .aux, stable across 3 passes, identical with or without lmodern): 3 pages total; figT1→p1, tabB1→p1, figP1→p2, tabB2→p2, figT2→p3. This is itself worth citing precisely: real LaTeX does not flush floats in one single cross-class relative order — figP1 (declared 3rd) and tabB2 (declared 5th) share a page while figT2 (declared 4th) is pushed to the next one, because t/b/p are independent per-class queues and the float-page-building decision is made with whatever's queued at that moment, not a global FIFO. → actual (render-pipeline, --v2 JSON word stream per page): also 3 pages; figT1→p1, tabB1→p1, figP1→p2, tabB2→p2, figT2→p2. Same total page count, same page-1 pair, same page-2 pair grouping (figP1+tabB2 share a page in both engines) — the one difference is which page absorbs the trailing t-float (figT2): pdflatex's page 3 vs. the pipeline's page 2. However, the pipeline packed noticeably more filler text per page than pdflatex did with the same lmodern fonts (all ~16 filler paragraphs landed on page 1 in the pipeline vs. spread over the whole 3-page document in pdflatex), a pre-existing page-density/line-count difference unrelated to this PR's diff (nothing here touches text metrics or \textheight), so I can't conclusively attribute the one-page offset on figT2 to a float-ordering defect in this PR versus that pre-existing density difference shifting where "page 3" begins. Recommend the PR add a page_para_control.rs-style controlled-line-count fixture (like its own enlargethispage_changes_the_goal_of_its_own_page, using filler(n,m)) for this exact mixed-placement scenario so the per-class-queue behavior is pinned precisely, independent of absolute density. Not a blocking finding as filed.

2. \enlargethispage immediately followed by a float — input: filler(1,50) + \enlargethispage{2\baselineskip} (also *, {30pt}, {-5\baselineskip}, {3\baselineskip}) before more filler, from the PR's own tests/page_para_control.rs::enlargethispage_changes_the_goal_of_its_own_page → pdflatex ground truth (independently reproduced at a hand-built crossover point: 37 one-line filler paragraphs + [h] figure + trailing text, lmodern): without \enlargethispage, the trailing "End." text overflows to page 2 (2 pages total); with \enlargethispage{2\baselineskip}, the same trailing text stays on page 1 (1 page total) — a clean, page-count-level confirmation that \enlargethispage extends the current page's usable height for whatever follows, not just the float itself → actual: the PR's own internal test asserts exact per-page line counts for five separate cases ([48, 2] for both \enlargethispage{2\baselineskip} and its starred form, [48, 2] for {30pt} placed mid-filler, [41, 9] for a negative {-5\baselineskip} shrinking the page, [46, 49, 5] for a larger {3\baselineskip} spanning three pages) and it passes. That's strictly more precise evidence than an external black-box reproduction can offer (it isn't sensitive to paragraph-wrapping granularity). My own external attempt to reproduce the same effect through the CLI at a hand-tuned crossover filler count was inconclusive (both variants landed on 2 pages) — most likely because my hand-written filler paragraph doesn't wrap to a controlled, fixed line count the way the PR's own filler(n,m) helper does, so a ~24pt (2-baselineskip) shift can be swallowed by where an uncontrolled paragraph happens to wrap; I don't read this as contradicting the internal test, which is the stronger, precise evidence and passes.

3. \nobreakdash-- inside a justified paragraph, narrow/tight enough that a break wants to fall at the dash — input: 40 repetitions of pages 1N--2N and (unmodified control) vs. the same with every -- replaced by \nobreakdash--, from the PR's own tests/page_para_control.rs::nobreakdash_forbids_the_break_after_its_dashes (asserts line 3 of the control ends "...pages 113–" and line 3 of the boxed version ends "...pages" with line 4 starting "113–213...") → pdflatex (independently reproduced, lmodern, PyMuPDF text extraction): exact match — control's 3rd extracted line ends '...and pages 113–'; boxed's 3rd line ends '...and pages' and its 4th starts '113–213 and pages...'. → actual: the PR's test encodes and passes this exact behavior (assert_eq! on both exact strings). No break falls after the dash in either the compiler's Inline::Penalty{value: INF_PENALTY} representation (per PR compiler: vertical \pagebreak is a bare penalty, amsmath \nobreakdash (#64; stacked on #568) #583's own change) or the render-pipeline's line breaker. Match, confirmed at both the source-citation level and independently against real pdflatex.

4. \newpage vs. \pagebreak under \raggedbottom — input: 5 one-line filler paragraphs, then either \newpage or \pagebreak, then "Second page text.", \raggedbottom set, lmodern → pdflatex: byte-identical PDFs (same file size 28256 bytes, same last-glyph y-position on page 1 to the pt, no underfull/overfull warnings either way) — i.e., real LaTeX shows no observable difference between the two under \raggedbottom, because \raggedbottom sets the page's trailing glue to its natural size regardless of whether \newpage's extra \vfil (vs. bare \pagebreak's absence of one, per compiler: vertical \pagebreak is a bare penalty, amsmath \nobreakdash (#64; stacked on #568) #583) is present; the \vfil distinction that PR compiler: vertical \pagebreak is a bare penalty, amsmath \nobreakdash (#64; stacked on #568) #583 surfaced only bites under \flushbottom (finding 2's oracle above, and compiler: vertical \pagebreak is a bare penalty, amsmath \nobreakdash (#64; stacked on #568) #583's own flushbottom_stretches_a_page_ended_by_pagebreak_not_newpage). → actual: render-pipeline's two --v2 JSON outputs differ only in sources/byte-offset metadata (expected, since the two source files have different names/lengths) — after stripping that metadata, the rendered geometry (page count, every glyph's position, every caret/hit-rect) is identical between the two. Correctly reproduces the real, empirically-verified "no difference under raggedbottom" behavior rather than assuming one.

Cleanup confirmation

$ git -C ~/flashtex-wt/review-584 status --porcelain crates/render-pipeline/vendor
(no output)