[robobun]

Problem

• One stylesheet builds to different bytes per host: rotate(atan2(0px, -1px)) is rotate(180deg) on Linux and rotate(3.14159rad) on macOS.
• The CSS parser calls asinf, acosf, atanf, atan2f, hypotf and cbrtf of the C library at 15 places (src/css/values/calc.rs:749). Bun 1.3.14 compiled them in. Since 1.4.0, log(32768, 2) is below 15.

Fix

• src/css/values/math.rs computes the six and both forms of log() in f64 with Bun's own code. It uses only IEEE arithmetic, so every host gets the same bits.
• A source lint fails on a new call to them.
• Verified: 86 new rows in test/js/bun/css/css.test.ts, 5 in color.test.ts. On main, 7 of the 86 fail with glibc 2.41. Also test/js/bun/css, test/bundler/css.
• Self-reviewed: 33 concerns raised, 25 addressed, 4 moved out with pow, 4 rejected (Notes).

Background

• A fold is a math function that the parser computes. One bit can change its unit.
• Not here: sin, cos, tan, exp, pow (27 sites). 1.3.14 called the C library for them too, and an owned pow costs 11% more cycles per oklch() declaration. Is that wanted?
• Considered an angle printer rule: round() and colors stay host-dependent.

Downsides

• Output changes where the C library was not correctly rounded. glibc 2.41: 500 of 50,000 sampled log(x, base) folds, 1 of 50,000 log(x) folds. glibc 2.39: also 706 of 250,000 inverse trigonometric folds.
• hypot(infinity, NaN) is now NaN, as WPT requires. Colors that use pow, sin or cos still differ per host.
• No cost found: -0.3% to +0.2% instructions per fold declaration, binary about 1.4 KB smaller.

Notes

What each host prints on main

Build 127608 ran main plus probe rows (commit 30c315f) on every lane.

Row	glibc 2.41	musl	macOS arm64 and x64	Windows
rotate(atan2(0px, -1px))	180deg	180deg	3.14159rad	180deg
rotate(acos(-1))	180deg	3.14159rad	3.14159rad	180deg
rotate(asin(1))	90deg	90deg	1.5708rad	90deg
rotate(atan(infinity))	90deg	1.5708rad	1.5708rad	90deg
folds of 500 that are not correctly rounded: asin	0	31	7 and 90	34
acos	0	43	7 and 107	6
atan	0	30	29	0
atan2	0	59	27	0
hypot	0	69	0	0
log(x, base)	162	162	162	162

A later step makes one bit visible. These are from this container, with the release build of main:

Input	glibc 2.41	musl libm preloaded
rotate: round(down, acos(-1), 180deg)	180deg	none
color: hsl(round(down, acos(-1), 180deg) 100% 50%)	#0ff	red
Bun.color("hsl(round(down, acos(-1), 180deg) 100% 50%)", "hex")	#00ffff	#ff0000
rotate: acos(0.53674)	57.538deg	1.00423rad

Bun.color("#ff0000", "lab") ends in 69.89099 on Linux and in 69.891 with the cbrtf of the Windows C runtime (emulated). #33328 saw 69.891 on Windows and on macOS arm64 in CI and made that test compare numerically. This PR restores the three exact rows.

The new rows on main, per host (release build of main, the 79 rows of css.test.ts at commit 3f02cd1)

Host	Rows that fail on main	With this PR
glibc 2.41 (the CI lanes, this container)	4	0
glibc 2.39 (the libraries of Ubuntu 24.04, run with their loader)	15	0
musl 1.2.5 math objects, preloaded	27	0
libm objects of the Windows C runtime that Bun links (10.0.26100.8249), with FMA3	8	0
the same, without FMA3	9	0
a libm that returns the other f32 neighbour of the exact value for half of the calls to sin, cos, tan, exp, log, pow (10 seeds)	not run	0

The musl and Windows rows are emulations on linux-x64: the math code of that library replaces glibc's in the Linux binary. No macOS emulation exists here. One of the 8 Windows rows is the subnormal cbrt row, where the emulation does not run the Windows code. The last row shows that the 79 rows do not depend on a function this PR leaves with the C library.

Since that commit, the two hypot(infinity, NaN) rows expect NaN, and two rows for hypot() of an infinity are new. Five rows for log(x) are new too. With glibc 2.41, main now fails 7 of the 86 rows: the 4 above, the two NaN rows and log(1.0686).

With this PR, css.test.ts and color.test.ts pass on all 11 test lanes of build 130207 (commit 2f90bd2), as in builds 128383 and 129283 before it: macOS arm64 and x64, Windows x64 and arm64, Alpine x64 and aarch64, Debian, Ubuntu and the ASAN lane.

Scope

• The 15 call expressions: asin, acos, atan (calc.rs:691-693), four atan2 in calc.rs and the hue in color.rs:2545, hypot with two arguments (calc.rs:1381), six cbrt in the conversions to Lab and OKLab (color.rs:3218-3228, :3471). Plus log(x, base) at calc.rs:451 and log(x) at calc.rs:453.
• 1.3.14 compiled 6 of the 12 functions in (Zig's std.math), which is 15 of the 43 call sites. It called the C library for sin, cos, tan, exp, log and pow. pow is a direct extern call, with a comment that marks the color path as hot (src/bun_core/lib.rs:324).
• log(x) called the C library in 1.3.14 too. It is here because it needs no new code: log(x, base) already has the ln kernel. A review of this PR asked for it.
• The other 27 sites stay as they are. The full version (all 43 sites, no libm import left in the CSS crates) is on branch robobun/330830bb/css-owned-math-wip. Measured there: per typed oklch() declaration 29,061 to 30,055 instructions (+3.4%) and about +11% cycles, because a correctly rounded pow in portable code is slower than glibc's. 559 of 849,994 sampled folds and 55 of 20,000 oklch() rules change on glibc 2.41. That trade needs a maintainer's decision, so it is not in this PR.
• Not the bits of 1.3.14 for asin, acos, atan, atan2. Zig's functions were not correctly rounded: 16,132, 4,368, 1,577 and 6,782 of 50,000 sampled folds differ from the f64 function rounded once. This PR gives the correctly rounded value on all 50,000 of each, which is what 1.4.x prints with glibc 2.41. The printed text differs from 1.3.14 for 882, 297, 493 and 490 of 50,000. hypot and log(x, base) print what 1.3.14 printed on all 50,000.
• On musl, acos, atan and atan2 of 1.4.x still have the bits of 1.3.14 (Zig's functions are ports of musl's). For those three, this PR is a change on musl and not a repair.
• Angle::to_degrees is not changed. 1.3.14 had the next f32 up for 180/pi. With it acos(0.5) prints 1.0472rad and round(up, acos(0.5), 60deg) is 120deg. Four rows pin the current constant.
• Not in scope, and not changed: a negative angle never prints in degrees. rotate(calc(atan2(0, -1) - 3.141593rad)) prints rotate(--2.38419e-7rad) (css: print negative numbers below 1 with a single minus sign #38516). A grey has a noise hue in lch() and oklch() (css: return a missing hue for a grey from conversions into lch, oklch, hsl and hwb #45201). On Windows, main prints lch(53.585% 0 0) for #808080, and with this PR it prints the noise hue of the other hosts, lch(53.585% .0000320981 158.199) (emulated). cosf in src/runtime/image/thumbhash.rs and the ** fold of the JS parser, which must equal the engine, also call the C library. atan2() of two lengths in different units reads its left operand twice (css: keep math functions over two different length units as written #38489). hypot() with three or more arguments squares in f32 and overflows for large values (css: wrap a one-argument min()/max() sum in calc() and give hypot() one fold for every argument count #46145).
• hypot(infinity, NaN) and hypot(NaN, infinity) are NaN, which prints 0. C's hypotf returns infinity there, and so did main for two arguments (3.40282e38). WPT css/css-values/hypot-pow-sqrt-computed.html has test_nan('hypot(infinity, NaN)'). Main already gives NaN for three arguments.
• css: wrap a one-argument min()/max() sum in calc() and give hypot() one fold for every argument count #46145 replaces parse_hypot with one fold in f64 for every argument count. It and this PR change the same helper in calc.rs, so the second to land has a conflict there and drops math::hypot or its call. The hypot() rows of the two PRs expect the same output.
• No user reported this. The only report is the red macOS row of css: keep math functions over two different length units as written #38489 in build 126706. That row folds through atan2, so it is expected to pass on macOS after this PR.

Why the kernels are correct

• Ports of Go 1.24.4 math (atan from Cephes, asin, acos, atan2 through it, log from FreeBSD's msun) and of msun's cbrtf. The attribution and the notices are in LICENSE.md.
• Every finite f32 against glibc's f64 function rounded once: asin, acos, atan, cbrt differ on 0 inputs.
• Random pairs against the f64 function rounded once: atan2 1 of 4.8 billion, hypot 0 of 1.2 billion, log(x, base) 0 of 1.2 billion.
• A digest over 297 million inputs is equal on x86_64 glibc, x86_64 musl and aarch64 musl (qemu).
• cargo check -p bun_css -p bun_css_jsc passes for x86_64-pc-windows-msvc, aarch64-apple-darwin, x86_64-unknown-linux-musl and aarch64-unknown-linux-gnu. cargo clippy -p bun_css has no finding.
• Suites run with the debug build: the 25 files of test/js/bun/css, the 5 of test/bundler/css, css-system-color-contexts.test.ts, css-system-color-mix-crash.test.ts and the new lint. css-fuzz.test.ts and nested-selector-expansion.test.ts hit their time limits in the debug build in this container (6 of 8 tests). Both pass with the release builds of main and of this PR.

Measurements (linux-x64, AMD EPYC, glibc 2.41. Release builds of main 017b243 plus the probe rows, and of this PR at commit 3f02cd1 on the same base. Two later changes are not in these builds: hypot lost one branch, and log(x) calls the ln kernel)

• Release binary: text 106,738,870 to 106,737,444 bytes (-1,426), data -40 (size). The math module is 2,310 bytes (nm -S). bloaty is not installed.
• C library references: the debug bun_css rlib has 13 undefined float names on main and 7 with this PR (cosf expf logf pow powf sinf tanf). Instructions in bun_css code that reference a C library float function: 552 to 405 (objdump). The binary no longer imports acosf asinf atan2f atanf hypotf.
• Calls at run time (preloaded counter): 50,000 folds of asin, acos, atan, atan2 or hypot make 50,000 calls on main and 0 with this PR. 50,000 log(x, base) folds: 100,000 to 0. 20,000 oklch() rules: atan2f 9,559 to 0, powf 543,500 and sincosf 89,671 as before.
• Instructions per declaration in bun build --minify, from sheets of 200,000 and 400,000 declarations, one worker thread, minimum of 7 to 9 runs, user-space counters of perf_event_open: atan2 18,823 to 18,774, acos 15,697 to 15,688, asin 15,100 to 15,093, atan 15,527 to 15,516, hypot 16,284 to 16,286, log(x, base) 15,626 to 15,650, typed oklch() 29,059 to 29,095, hex color 11,189 to 11,200.
• Cycles per declaration do not move beyond the spread of repeated runs: atan2 7,769 to 8,038 on main and 7,844 to 7,964 with this PR, acos 6,625 and 6,663 against 6,563 and 6,557, oklch() 12,279 to 12,582 against 11,703 to 11,793.
• One call alone, in a loop where each call waits for the one before it (cycles, glibc 2.41 against this PR): asin 39 to 105, acos 41 to 108, atan 59 to 78, atan2 77 to 90, hypot 32 to 32, log(x, base) 53 to 96, cbrt 75 to 79. The owned functions divide and take a square root in f64. A fold declaration costs about 6,500 cycles, so this does not show above.
• log(x), measured at commit 2f90bd2: one call is 38 instructions and 34 cycles with glibc's logf, and 68 instructions and 86 cycles with the ln kernel. Of 50,000 sampled log(x) folds, main is not correctly rounded for 49 and this PR for 0. The printed text changes for 1 (.0897904 to .0897905).
• valgrind, perf and hyperfine are not installed, so there is no cachegrind count and no wall-clock comparison.
• Output on glibc 2.41, main against this PR: 500 of 849,994 sampled folds change, all of them log(x, base). 0 of 120,000 lines of an oklch() sheet, 0 of 13,500 Bun.color results, 30 of 30 outputs of the 15 stylesheets in test/js/bun/css/files.
• Output on glibc 2.39, main against this PR: 100 acos, 123 asin, 42 atan and 441 atan2 of 50,000 each (100,000 for atan2), 131 of them change between deg and rad. 24 of 13,500 Bun.color results. The 500 log(x, base) folds.
• Same binary, two hosts, lines that differ over the same corpora (3.6 million lines):

Pair of hosts	main	this PR	what is left
glibc 2.41 and glibc 2.39	801	71	tan
glibc 2.41 and musl (emulated)	1,302	375	sin, cos, tan, colors through pow
glibc 2.41 and Windows with FMA3 (emulated)	5,914	190	the same, and exp, log, pow
Windows with and without FMA3 (emulated)	19	0

• A color that is mapped into the sRGB gamut still depends on pow, sin and cos. rgb(from oklch(12.83% 0.399 253.8) r g b) is #00002d with glibc and #00061a with the Windows libm, on main and with this PR. rgb(from oklch(35.42% 0.364 137.7) r g b) is #174800 with glibc and #074a00 with musl on main. With this PR it is #174800 with both. But with a libm that returns the other f32 neighbour for half of the calls to pow, sin and cos, it is #074a00 in 105 of 300 runs. So no gamut row is in the tests.

Self-review

• Rejected: a gamut-mapping row (reason above). Clippy's disallowed-methods as the guard: it is workspace-wide, and these methods are fine outside the CSS crates. The forbidden-import check of the binary: it covers ELF release lanes only. A scan for extern declarations of these names: none exists.
• Moved out with pow: a faster pow kernel, the Bun.color throughput of the pow path, tests for the pow arms, and the five .powi(2) in color.rs.

---

[human-review] gate passed · iteration 1 · 8 files touched

fails on main (without fix)

ASAN without fix: BUILD FAILED (no junit output)
$ BUN_DEBUG_QUIET_LOGS=1 bun scripts/build.ts --profile=debug --quiet test "--reporter=junit" "--reporter-outfile=/tmp/pr_gate.xml" test/internal/source-lints/css-host-math.test.ts test/js/bun/css/color.test.ts test/js/bun/css/css.test.ts
rustup spent 17s installing the pinned toolchain (nightly-2026-09-15); it was missing or incomplete on this machine
[ninja] fetching https://github.com/oven-sh/ninja/releases/download/bun-ninja-5ecd8831/bun-ninja-linux-x64.zip
[ninja] extracted to /root/.bun/build-cache/ninja/bun-ninja-5ecd8831 (1.5s)
ninja: Entering directory `/workspace/bun/build/debug'
[1/4] fetch lolhtml
[lolhtml] up to date
[2/4] fetch rust-argon2
[rust-argon2] fetching sru-systems/rust-argon2@ed81866f
[rust-argon2] applying legacy-low-memory.patch
[rust-argon2] applying fallible-memory.patch
[rust-argon2] done → /workspace/bun/vendor/rust-argon2 (2.2s)
[2/4] cargo plan → /workspace/bun/build/debug/rust-target/plan.json
FAILED: [code=1] rust-target/plan.json /workspace/bun/build/debug/rust-target/plan.json 
/workspace/bun/build/release/bun /workspace/bun/scripts/build/stream.ts cargo --console /workspace/bun/build/release/bun /workspace/bun/scripts/build/r
... (truncated)

release without fix: 33 failed, 72 skipped
bun test v1.4.3-canary.1 (367d939d9)

test/internal/source-lints/css-host-math.test.ts:
29 |       });
30 |     }
31 |   }
32 |   // Guard against repoRoot resolving wrong, which would make the ban pass vacuously.
33 |   expect(scanned).toBeGreaterThan(50);
34 |   expect(found).toEqual([]);
                     ^
error: expect(received).toEqual(expected)

- []
+ [
+   "src/css/values/color.rs:2545: let mut h = b.atan2(a) * 180.0 / core::f32::consts::PI;",
+   "src/css/values/color.rs:3218: x.cbrt()",
+   "src/css/values/color.rs:3223: y.cbrt()",
+   "src/css/values/color.rs:3228: z.cbrt()",
+   "src/css/values/color.rs:3471: let (l, a, b) = multiply_matrix(&LMS_TO_OKLAB, a1.cbrt(), b1.cbrt(), c1.cbrt());",
+   "src/css/values/calc.rs:451: return Ok(Calc::Number(value.log(base)));",
+   "src/css/values/calc.rs:453: Ok(Calc::Number(value.ln()))",
+   "src/css/values/calc.rs:691: TrigFnKind::Asin => x.asin(),",
+   "src/css/values/calc.rs:692: TrigFnKind::Acos => x.acos(),",
+   "src/css/values/calc.rs:693: TrigFnKind::Atan => x.atan(),",
+   "src/css/values/calc.rs:749: if let Some(v) = av.try_op_to(&**bv, (), |_, x, y| Angle::Rad(x.atan2(y))) {",
+   "src/css/values/
... (truncated)

passes on PR (with fix)

ASAN with fix: 73 skipped
$ BUN_DEBUG_QUIET_LOGS=1 bun scripts/build.ts --profile=debug --quiet test "--reporter=junit" "--reporter-outfile=/tmp/pr_gate.xml" test/internal/source-lints/css-host-math.test.ts test/js/bun/css/color.test.ts test/js/bun/css/css.test.ts
bun test v1.4.4 (367d939d9)

test/internal/source-lints/css-host-math.test.ts:
(pass) the CSS crates do not call asin, acos, atan, atan2, hypot, cbrt, ln or log of the C library [1559.28ms]

test/js/bun/css/color.test.ts:
�[38;2;255;0;0m[object Object]
(pass) console.log(color({"r":255,"g":0,"b":0}, "ansi-24bit")) [1.90ms]
�[38;5;196m[object Object]
(pass) console.log(color({"r":255,"g":0,"b":0}, "ansi-256")) [1.35ms]
�[91m[object Object]
(pass) console.log(color({"r":255,"g":0,"b":0}, "ansi-16")) [1.17ms]
(pass) color({"r":255,"g":0,"b":0}, "{rgb}") = {"r":255,"g":0,"b":0} [1.27ms]
(pass) color({"r":255,"g":0,"b":0}, "ansi-24bit") [14.61ms]
(pass) color({"r":255,"g":0,"b":0}, "ansi-16") [2.25ms]
(pass) color({"r":255,"g":0,"b":0}, "ansi256") [1.41ms]
�[38;2;0;255;0m[object Object]
(pass) console.log(color({"r":0,"g":255,"b":0}, "ansi-24bit")) [0.52ms]
�[38;5;46m[object Object]
(pass) console.log(color({"r":0,"g":255,"b":0}, "ansi-
... (truncated)

release with fix: 72 skipped
$ bun scripts/build.ts --profile=release
rustup spent 9s installing the pinned toolchain (nightly-2026-09-15); it was missing or incomplete on this machine
[configured] bun-profile → bun (stripped)
  target       linux-x64-gnu
  build type   Release
  build dir    ./build/release
  revision     2f90bd2a0d
  features     lto, baseline

23 deps, 228 codegen, 1218 objects in 14882ms

ninja: Entering directory `/workspace/bun/build/release'
[1/4] fetch lolhtml
[lolhtml] up to date
[2/4] fetch rust-argon2
[rust-argon2] up to date
[2/4] cargo plan → /workspace/bun/build/release/rust-target/plan.json
270 units: 194 lib, 16 proc-macro (host), 21 custom-build (host), 17 run custom-build, 17 lib (host), 4 run custom-build (host), 1 rlib
[3/4] reconfigure
[1/1577] mkdir stamps
[2/1577] mkdir codegen
[3/1577] gen bake.{client,server,error}.js
-> bake.client.js, bake.server.js, bake.error.js
[4/1577] install /workspace/bun
bun install v1.4.3-canary.1 (367d939d9)

Checked 22 installs across 44 packages (no changes) [6.93s]
[5/1577] install /workspace/bun/packages/bun-error
bun install v1.4.3-canary.1 (367d939d9)

Checked 1 install across 2 packages (no changes) [374.00ms]
[6/
... (truncated)

diff hotspot

LICENSE.md                                       |   1 +
 src/css/values/calc.rs                           |  25 +--
 src/css/values/color.rs                          |  16 +-
 src/css/values/math.rs                           | 218 +++++++++++++++++++++++
 src/css/values/mod.rs                            |   1 +
 test/internal/source-lints/css-host-math.test.ts |  35 ++++
 test/js/bun/css/color.test.ts                    |  28 ++-
 test/js/bun/css/css.test.ts                      | 123 +++++++++++++
 8 files changed, 428 insertions(+), 19 deletions(-)

gate history · 1 passed · 0 rejected · iteration 1

evidence per changed file

file                                              reads  edits  tests
LICENSE.md                                            0      0     79
src/css/values/calc.rs                                2      0     77
src/css/values/color.rs                               0      0     76
src/css/values/math.rs                                1      2     80
src/css/values/mod.rs                                 0      0     77
test/internal/source-lints/css-host-math.test.ts      0      2     20
test/js/bun/css/color.test.ts                         0      0     22
test/js/bun/css/css.test.ts                           4      3     63

[robobun]

^{Updated 3:25 PM PT - Oct 21st, 2026}

✅ @robobun, your commit 2f90bd2a0db8197f863a65af13cbe7f9a8d3ea97 passed in Build #130207! 🎉

---

🧪   To try this PR locally:

bunx bun-pr 45759

That installs a local version of the PR into your bun-45759 executable, so you can run:

bun-45759 --bun

[robobun]

Status: closed, not merged. A maintainer did not take this change in #47025, which consolidated the open CSS parser pull requests: "right or harmless, but not worth its code, the bigger output or the behavior it changes". The CSS parser keeps the math functions of the C library.

#47025 has the change of #38489 with test rows that do not depend on the C library, so the red macOS row that started this work is gone from main.

How the problem was reproduced:

• Build 127608 ran main plus probe rows on every lane. macOS prints rotate(3.14159rad) for rotate(atan2(0px, -1px)). Linux and Windows print rotate(180deg).

This PR: #45759

[robobun]

#46145 replaces parse_hypot with one fold for every argument count. It adds the squares in f64 and takes one sqrt, so it has no call to hypotf. It removes the two-argument hypot helper in calc.rs that this PR changes, so the two conflict there.

One difference in the rows: this PR expects 3.40282e38 for hypot(infinity, NaN) and hypot(NaN, infinity). #46145 prints 0 (NaN). WPT css/css-values/hypot-pow-sqrt-computed.html has test_nan('hypot(infinity, NaN)') with the comment "NaN is infectious, so hypot(infinity, NaN) is NaN even though JS Math.hypot(Infinity, NaN) returns Infinity". Chrome 153 prints calc(infinity).

[coderabbitai]

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

• Configuration used: Repository: oven-sh/bun/.coderabbit.yaml
• Review profile: ASSERTIVE
• Plan: Advanced
• Run ID: 927ac578-96a8-4377-97da-9a87830ff04c

📥 Commits

Reviewing files that changed from the base of the PR and between c5cd983 and 2f90bd2.

📒 Files selected for processing: 4

• src/css/values/calc.rs
• src/css/values/math.rs
• test/internal/source-lints/css-host-math.test.ts
• test/js/bun/css/css.test.ts

Included review availability: This review used your included allowance. Your plan provides up to 10 included reviews per hour; 0 remain after this review.

Walkthrough

The CSS values code now uses shared math helpers for selected trigonometric, logarithmic, hypotenuse, and cube-root operations. The helpers use f64 implementations and handle special values. Tests check deterministic results, and a source lint checks direct host math calls.

Changes

CSS Math Determinism

Layer / File(s)	Summary
Shared math helpers src/css/values/math.rs, src/css/values/mod.rs, LICENSE.md	Added shared math helpers with f64 kernels, cube-root handling, module wiring, and license attribution.
CSS calculation and color integration src/css/values/calc.rs, src/css/values/color.rs	Replaced direct floating-point calls with shared helpers in CSS calculations and color conversions.
Determinism tests and source lint test/internal/source-lints/css-host-math.test.ts, test/js/bun/css/color.test.ts, test/js/bun/css/css.test.ts	Added source lint coverage and tests for deterministic math and color results, including exact outputs and special values.

Suggested reviewers: jarred-sumner

Priority: ⬇️ Low

Merge Risk: ⚪ Minimal · up to 2f90b

No identified issue currently prevents merging this CSS math change after normal checks.

Pre-merge checks: 4

Check name	Status	Explanation
Title check		The title clearly and concisely describes the main change: Bun-owned CSS math implementations for the listed functions.
Linked Issues check		Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check		Check skipped because no linked issues were found for this pull request.
Description check		The description provides the required information. It explains the problem, implementation, scope, limitations, verification steps, test results, and performance measurements. It does not use the temp…

Full details: Description check

Explanation

The description provides the required information. It explains the problem, implementation, scope, limitations, verification steps, test results, and performance measurements. It does not use the template headings exactly, but the required content is present and detailed.

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[claude]

Nothing blocking. The comments below are optional suggestions. There is no need to push a fix for them before merging.

Beyond the inline findings, I also diffed the kernels in src/css/values/math.rs control-flow-by-control-flow against Go 1.24.4 math/atan.go, asin.go, atan2.go, log.go and msun s_cbrtf.c (special cases, signed zero, infinities, the subnormal cbrt scaling, the inline frexp) and found them faithful. The two-argument hypot change to NaN for hypot(infinity, NaN) matches WPT and the existing three-argument path, so it was ruled out as a regression; the f64 sum-then-sqrt is exact in f64 and only differs from a correctly rounded hypotf by double rounding, which is rare and not host-dependent.

Extended reasoning...

The change adds an in-tree f64 math module for asin/acos/atan/atan2/hypot/cbrt/log(x, base) and rewires the CSS calc and color folds to it, plus a source lint and exact-output tests; it touches no security-sensitive surface. The inline findings (remaining host-dependent sites such as one-argument log and 3+ argument hypot, the atan2 mixed-unit path, the lint omitting log, and the Windows grey-hue output change) are what a human should weigh, so the decision is defer rather than approve.

Additional findings (outside the current diff — GitHub can't attach inline comments there):

• 🟣 src/css/values/calc.rs — Stylesheet authors who pass three or more arguments to hypot() still get an overflowed 3.40282e38 for large lengths while the two-argument form now folds correctly. src/css/values/calc.rs:848-866 squares each operand in f32 with powi2 and b.powf(2.0) and sums in f32, so hypot(3e30px, 4e30px, 0px) is infinity, whereas the new f64 path at src/css/values/math.rs:33 gives 5e30 for hypot(3e30px, 4e30px). The PR deliberately fixed one arity of the same helper. Fix: fold every argument count through one f64 sum of squares (as #46145 proposes) in parse_hypot, so adding a third argument cannot change the result from 5e30 to infinity.

  Why this was flagged

  Input line-height: calc(hypot(3e30, 4e30, 0) / 1e30) enters parse_hypot at src/css/values/calc.rs:835 with args.len() == 3, skips the two-argument branch at :841-845 and squares in f32 at :848 (powi2, src/css/values/calc.rs:1390) and :855 (a + b.powf(2.0)). 3e30 squared overflows f32 to infinity, sqrtf32 at :866 keeps it, and the output is 3.40282e38; the two-argument sibling right above it, now routed through math::hypot, prints 5 for the same values (pinned at test/js/bun/css/css.test.ts:279). The base branch already overflowed in the three-argument path, which is why the finders called it pre-existing, but the base's two-argument path (C hypotf) also did not overflow, so the inconsistency between arities is unchanged rather than new; what this PR adds is a stated guarantee of identical bytes for hypot() that holds only for one arity, and REVIEW.md asks that sibling paths of a changed helper be fixed together. The fix is a single f64 accumulation for every arity in parse_hypot.

  Verification: pre-existing. parse_hypot at /home/claude/bun/src/css/values/calc.rs:841-845 routes only args.len() == 2 through f64 math::hypot. For three or more arguments it squares in f32 at :848 and :855 and takes sqrtf32 at :866, so hypot(3e30, 4e30, 0) prints 3.40282e38. On the base the 2-arg path called a.hypot(b) and produced 5e30, so the 3-arg overflow already exists on the base.

[robobun]

Reply to the review finding on hypot() with three or more arguments (src/css/values/calc.rs:848-866):

• Not changed in this PR. css: wrap a one-argument min()/max() sum in calc() and give hypot() one fold for every argument count #46145 folds every argument count through one sum of squares in f64, which removes the overflow for hypot(3e30px, 4e30px, 0px).
• The two PRs change the same helper in calc.rs. The hypot() rows of this PR expect the same output as css: wrap a one-argument min()/max() sum in calc() and give hypot() one fold for every argument count #46145 prints.

The two other findings are done in 2f90bd2: log(x) uses the ln kernel, and the lint fails on f32::ln and f32::log.

[claude]

Code review found no issues

No high-confidence issues detected in this change.

[Jarred-Sumner]

Not taken in #47025 (7942008), which consolidated the open CSS parser pull requests. It is right or harmless, but not worth its code, the bigger output or the behavior it changes.