T130: non-integer order from calc() rounds half toward +infinity and clamps to int, as Chrome does

[thejackshelton]

What changed

T130: a non-integer order from a math function now rounds as Chrome does. Blink's CSSMathFunctionValue::ComputeInteger (css_math_function_value.cc 89-97, range kInteger) uses RoundHalfTowardsPositiveInfinity: floor(v + 0.5) in double (math_extras.h 133-139), then ClampToWithNaNTo0. All sources are at 145.0.7632.6 (BSD). Chrome 145 getComputedStyle agrees on every probed value: calc(-1.5) gives -1, calc(0.5) gives 1, calc(0.49999999999999994) gives 1, and calc(3e9) and a 3000000000 literal both give 2147483647.

• Engine:
  • units.ts adds orderInteger.
  • The environment pass (environment.ts) resolves order with it at every DPR.
  • validate.ts accepts any finite order, because the compiler sends a folded number calculation unrounded. NaN and infinities are still rejected.
  • Planted faults orderHalfEven and orderUnclamped (block.ts, translate harness.ts).
• Compiler:
  • css/values.ts no longer refuses a non-integer order calculation.
  • emit/web-css.ts writes it as calc(<n>), so Chrome rounds it the same way the engine does.
  • An infinite or NaN order calculation is still refused, with its reason.
• New fixture values-order-calc-round (ltr and rtl): 25 flex rows of [r, X, r] covering halves of both signs, values beyond the int range, nested min/max/clamp, and var(). Each plant fails it.
• Regenerated outputs are in their own commits (871c1f5 and e6d86f8, which name the commands). Every existing capture and vector is byte-identical.

What passed

Caught up with master to the train 1 freeze base 1f17b6e (#64 SIZE-ar, #65, #66 INL1a breaks, #67 REPL-a engine, #68 T116):

• block.ts, harness.ts and their fault lists keep master's four line-break faults and T130's two order faults; vectors/README.md takes master's 42-field line and aspectRatio entry with T130's order sentence.
• environment.ts takes master's styleNeedsEnvironment and keeps T130's order check, now also for a replaced child: REPL-a's replaced leaves carry order, and without the check a replaced flex item's order 1.5 reached the engine unrounded at DPR 1. calc.test.ts pins it (it fails without the replaced check: [10, 0] instead of [0, 20]).

Stacked on CALC-2 (#60, calc2-contexts e6e6b7f, itself on T128) for the train, with the PM ruling's retarget: values-reject-order-fraction (CALC-2's pin of the refusal of order: calc(1.5), which T130 makes accepted) now pins order: calc(1 / 0), still refused with "it divides by zero or produces an infinite or NaN value" (the compiled diagnostic matches the spec's span and message prefix). The intent is kept: an order calculation Dragon still refuses. fixture-groups/values.ts and units.test.ts keep both sides.

docs/ports.json registers T130's citations, per the PM ruling: css_math_function_value.cc lists calc.test.ts as a reference, and a new entry math_extras.h (bsd-apple, header-bsd-2, lines 133-139) is referenced by calc.test.ts. /tmp/heavy-lease.sh pnpm regen rebuilt the generated outputs in their own commit (ebc17b9, fixed point after 3 passes).

On ebc17b9:

• pnpm typecheck: pass.
• Targeted: engine.test.ts, vectors.test.ts, calc.test.ts, units.test.ts, values.test.ts, chrome-ports.test.ts, regen.test.ts: 687 pass, 1 skipped (the DRAGON_REGEN_CHECK suite).
• /tmp/heavy-lease.sh pnpm test on ebc17b9: queued behind the other members' regens; the result follows in a comment.
• From the branch's own regen: engine and Chrome agree on 102/102 nodes at every DPR, in both directions; both plants are caught; the Swift and Kotlin translated engines agree; breaks: the engine equals Chrome on 1386/1386.
• Pre-PR audit (AGENTS.md step 3) of every changed source and test file: no instance found.

Train 1 (freeze base f78f198 / 1f17b6e)

This PR is a member of merge train 1 (AGENTS.md step 8), in this order: #59 T128, #60 CALC-2, #61 T130, T129, seld-r1. The train merges each member onto the previous position, so members that touch the same lines are stacked, with their overlaps resolved and reviewed in the member branches rather than in the train: CALC-2 merges T128, T130 merges CALC-2, and T129 merges T130. Until an earlier member lands, GitHub shows its changes in this diff too. seld-r1 sits on master alone; its merges onto the earlier positions were simulated clean, and every position's reviewed-path patch id equals its member's clean head (git merge-tree chain plus patchIdOver), so each position should be vouched at landing.

The device lanes, and the regen of each position, run in the train itself: one device run per position. Master now has T116 (#68), so device-pixels is iOS 57 / Android 86 on master; each position's device run is compared against that.

Changed tests and checks

• The validator's order rule changes from integer to any finite number. The reason: the engine now owns the rounding, as the PM ruling requires (the compiler may not round). calc.test.ts pins that NaN is still rejected.
• New tests:
  • calc.test.ts: orderInteger against 21 Chrome rows, the plants, and document order for ties.
  • units.test.ts: the compiler sends the value unrounded, web CSS keeps calc(), a literal order: 1.5 is still invalid, and infinite or NaN stays refused.
  • values.test.ts: the plants and the getComputedStyle order of all 150 items.
• values-reject-order-fraction (from CALC-2) is retargeted from calc(1.5) to calc(1 / 0), as above.
• No tolerance is loosened and no check is removed.

🤖 Generated with Claude Code

Note

Add Chrome-compatible rounding and clamping for non-integer order from calc()

• Non-integer order values from calc() are now passed through unrounded and rounded by the engine: half ties round toward positive infinity, then values clamp to the signed integer range, matching Blink's ComputeInteger (see units.orderInteger in units.ts).
• Style validation no longer rejects fractional order values; the environment pass resolves them via the new environment.resolveOrder in environment.ts.
• Two fault switches were added (orderHalfEven, orderUnclamped) in block.ts, wired into the translate harness and generated Swift/Kotlin output.
• Also fixes border shorthand parsing: calc()/min()/max()/clamp() widths in physical and logical border shorthands are now parsed as border-width values instead of being rejected (values.ts, border.ts, logical.ts).
• Adds parity fixtures and vectors for these cases, and emits non-integer order values to web CSS as calc(...) declarations in web-css.ts.
• Behavioral Change: EngineFaults in the generated Swift/Kotlin Block files gained two new fields; out-of-tree consumers of these generated types must be updated.

^{Macroscope summarized ebc17b9.}

[macroscopeapp]

Approvability

Verdict: Not approved

Macroscope's review found this PR not approvable — Although many changed files are generated parity artifacts, the source changes modify CSS acceptance/emission and existing flex and order layout behavior across production paths. The new intrinsic measurement logic and cross-target generated engine changes make this broader than a small, self-contained compatibility fix.

^{You can add or adjust custom eligibility rules. Learn more.}

Dismissing prior approval to re-evaluate ebc17b9