fix(css): order a joined seam's list, and gather a layer block too big to assemble - #22219

Summary

Two findings from the CSS idempotence sweep, both the same shape: the printer wrote output that was not its own fixed point. With them the sweep goes from 1 finding to 0, which is what blocks running the invariants job over the full corpus — it sweeps 921 of the 955 stylesheets a local run builds, and the finding lived in the 34 it misses.

Joining two at-rule blocks with one prelude joins the pair meeting at the seam, and _joinRuleEntries concatenates the two preludes rather than ordering them. Every other join settles its list afterwards — _mergeAdjacentRules through finish(), the distant merges through _orderDistantLists — this one never did, so @media print{.b{x:1}}@media print{.a{x:1}} printed .b,.a where a second pass writes .a,.b. It is ordered at the seam now, which is the one place a joined block settles its list, once per join rather than once per child, so a run stays linear. @media, @supports, @layer, @container, @scope and @starting-style all reach it.

The other is the layer gather. A named @layer block past _STREAM_MIN_NODES streams its body, so its text is out before it closes and the parent's gather, which reads a body whole, never sees it: @layer u{@layer a{}@layer a{<4096 rules>}} wrote two blocks of one layer where a second pass wrote one. Past ~6000 rules neither pass gathers, so the bug is there too and idempotence cannot see it. A block whose layer a sibling already opened is now held rather than streamed — read off the source as it is consumed, the printed opener not existing yet — so it stays assembled and _mergeNamedLayerBlocks takes it. Only that block is materialized, and only where a layer is written twice. That keeps which blocks gather off whether one was small enough to assemble, which is what _mergeNamedLayerBlocks already says.

It costs 486 bytes. Over the 2124 stylesheets the comparison corpus installs, 2123 are byte-identical and Tailwind 4 + daisyUI 5 grows 486 (52,654,105 → 52,654,591). The gather moves a body, which parts one rule from the selector list it used to join — a merge inside the block the gather grew, which is already printed by the time the gather runs. Re-running the sibling merge after the gather recovers none of it, so that is left as its own change. Time is 1256 ms against a 1231 ms baseline over 120 stylesheets and 15.9 MB, best of three with runs spanning 1231–1435 ms either way; heap on the daisyUI sheet is 25.2 MB against 25.8 MB.

What kind of change does this PR introduce?

fix

Did you add tests for your changes?

Yes — unit tests for every at-rule whose block holds rules, a run of joins and a seam that joins nothing; for the held block whatever the one before it carries, a run of two streamed blocks, an anonymous @layer, another layer and a dotted name. Two existing tests asserted the old behaviour and now assert the gathered output. configCases/css/minify-at-rule-seam-order and configCases/css/minify-layer-gather-large-block read both off an emitted stylesheet and check it against a second pass; the gather's filler is generated by a loader rather than checked in, the case needing a few thousand rules to reach the stream. Disabling either fix fails its own tests and leaves the controls passing, which I checked by doing it.

Does this PR introduce a breaking change?

No. The same rules are printed — the joined seam's list is written in the printer's own order, and a layer written twice prints as the one block it is, in the order the two were written.

If relevant, what needs to be documented once your changes are merged or what have you already documented?

n/a

Use of AI

AI was used. It reduced the sweep finding from 744 KB to the two causes, measured the byte, time and heap cost against a same-session baseline, wrote the change and the cases, and broke each fix to check a case catches it. I reviewed the result.

Summary by CodeRabbit

• Bug Fixes
  • Improved CSS minification for joined at-rule blocks, producing consistent selector ordering and stable output across repeated minification passes.
  • Fixed handling of large, repeated named @layer blocks so their contents are gathered correctly in source order.
  • Preserved separate output for rules that cannot be safely combined, while continuing to merge compatible CSS blocks.