assert: render Myers diffs natively

[dylan-conway]

Problem

• Native myersDiff() returned a JS array of { kind, value } objects, one per line or char. myers_diff.ts built the diff text from it.
• The value conversion corrupted text. FromAny for &[u8] (src/jsc/JSValue.rs) decodes a Latin-1 line as UTF-8, so { s: "línea" } printed as 'l�nea'. FromAny for &[u16] returns an array of numbers, so a diff with emoji or CJK on both sides printed + 32,32,115,58,... instead of the line.
• With one Latin-1 side and one UTF-16 side, the char diff compared raw bytes of two encodings and printed garbage.

Fix

• printMyersDiff and printSimpleMyersDiff now render in node_assert.rs, into one Latin-1 or UTF-16 buffer, and return one string (or { message, skipped }). The JS module only passes the internal/util/colors escapes. myersDiff (the raw list) is still exported.
• When the encodings differ, the Latin-1 side is widened to UTF-16 first. Both diff kinds then compare code units, as Node does.
• Output carries the diff mode (lines, check_comma_disparity) next to the render mode, so the two can not be mismatched.
• Verified: test/js/node/assert/assert.test.cjs (three new tests fail on main), the rest of test/js/node/assert/ and the 17 vendored test-assert*.js files.

Background

• deepStrictEqual diffs the inspected values by line. strictEqual on strings diffs by char, only with colors on, so that test spawns a child with FORCE_COLOR=1.
• A JS string is stored as Latin-1 or UTF-16. byte_slice() / utf16() on bun_core::String give its code units. Latin-1 bytes above 0x7F are not valid UTF-8.
• FromAny is the generic Rust to JS conversion. It has no notion of string encoding.

Notes

Differential check against Node: 31 strictEqual / deepStrictEqual / partialDeepStrictEqual failures (objects, arrays, comma disparity, ... collapsing at 6, 7, 8 and 9 equal lines, empty strings, trailing whitespace, Latin-1, UTF-16 and mixed inputs), with and without FORCE_COLOR. With this branch the output is byte for byte identical to Node in every case except partialDeepStrictEqual, where Node 26 has a newer gray rendering that main does not have either. Against the current release exactly six cases change: the Latin-1, UTF-16 and mixed cases above.

The three new tests that fail on main are the Latin-1 line diff, the UTF-16 line diff, and the colored char diff. The trailing spaces assertion in the Latin-1 test also passes on main. It stays as coverage of the trimEnd port in render_lines. test/js/node/assert/ is 411 tests.

The clippy (needless_pass_by_value) and mordant (bare_bool_args) findings on the first revision are fixed by passing Output by reference and moving the two flags into its variants.

[coderabbitai]

Warning

Review limit reached

Your included review limit has been reached.

You’re in a promotional period — use the checkbox below to run this review for free:

• Run review for free

_{On-demand reviews are free for the next 30 days. After that, they cost $0.25 per reviewed file.}

How can I continue?

Run this review now using the option above, or comment @coderabbitai review --use-credits.

You can also wait for the limit to reset (next review available in 3 minutes), then comment @coderabbitai review or push new commits to the PR.

An organization admin can change what happens after included review limits in Billing.

How do review limits work?

CodeRabbit enforces per-developer PR review limits within each organization.

For paid Pro and Pro+ reviews, CodeRabbit uses a developer's included PR review attempts over the past 7 days to set the current hourly allowance. At typical activity levels, the full plan allowance applies. Higher sustained activity can lower the allowance until earlier attempts leave the 7-day window.

Please refer docs for additional details.

Review details

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro

Run ID: 9189ac4c-c316-47c5-bf93-92a109fff431

📥 Commits

Reviewing files that changed from the base of the PR and between 4448a2e and 320783e.

📒 Files selected for processing (5)

• src/js/internal/assert/assertion_error.ts
• src/js/internal/assert/myers_diff.ts
• src/runtime/node/node_assert.rs
• src/runtime/node/node_assert_binding.rs
• test/js/node/assert/assert.test.cjs

---

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

[claude]

I reviewed this PR and didn't find any bugs. Since it adds ~200 lines of new native rendering code with a generic CodeUnit/DiffText trait design and changes the mixed-encoding handling path, a human look would still be worthwhile.

What was reviewed:

• render_lines/render_simple traced line-for-line against the removed JS printMyersDiff/printSimpleMyersDiff — collapse thresholds, diff[idx+1]/[idx+2] back-references, and the trimEnd guard preserving the leading \\n all match.
• is_js_whitespace checked against the ECMA-262 WhiteSpace + LineTerminator set; operating on code units is safe since none of the listed code points fall in the surrogate range.
• Latin-1 → UTF-16 widening via u16::from(b) is correct for the 0x00–0xFF range; colors_from_js bytes are always ASCII from internal/util/colors so append_ascii's per-byte widening is sound.

Extended reasoning...

Overview

This PR moves printMyersDiff and printSimpleMyersDiff from src/js/internal/assert/myers_diff.ts into src/runtime/node/node_assert.rs, so the native myersDiff path renders the final diff string directly instead of returning a Diff[] array for JS to walk. It adds an Output enum, a Colors struct, and two small traits (CodeUnit, DiffText) to keep the renderer generic over Latin-1 bytes vs UTF-16 code units and over char vs line values. The mixed-encoding path is reworked: instead of re-encoding both sides to UTF-8 (line diff) or comparing mismatched byte slices (char diff), the Latin-1 side is widened to UTF-16. Two new host functions are exported from node_assert_binding.rs; the JS module becomes a thin wrapper passing internal/util/colors. Three tests are added with expected messages captured from Node v24.

Security risks

None identified. This is error-message rendering for node:assert; inputs come from util.inspect output on user values, not from untrusted network/file data. No parsing of external formats, no allocation sizing derived from untrusted lengths beyond what the existing diff algorithm already handles (with its DiffTooLarge/InputsTooLarge guards preserved).

Level of scrutiny

Medium. The change is not mechanical: it ports ~60 lines of JS control flow into ~200 lines of generic Rust, introduces a small trait-based design for output-code-unit polymorphism, and rewrites the encoding-mismatch branch. That said, it is confined to assertion error message formatting — a wrong output here degrades diagnostics rather than corrupting state — and the port is a direct transliteration whose behavior is pinned by exact-string tests against Node.

Other factors

I compared the Rust renderers against the removed JS line-by-line: the previousType && kind !== previousType && previousType === Equal condition simplifies to exactly what the Rust checks (the JS previousType && short-circuit on Insert=0 is subsumed by the === Equal test); the nopCount +1/+2/≥+3 branches, ... emission, and skipped flag match; the trailing trimEnd is reproduced with a code-unit loop that stops at length 1 to keep the leading newline (matching JS's trim-then-prepend). The is_js_whitespace set matches ECMA-262 WhiteSpace ∪ LineTerminator, and since none of those code points are surrogates, testing UTF-16 code units directly is safe. Memory: all Vecs are locals dropped at scope exit, borrowed &[T] line slices never outlive their input strings, and transfer_to_js hands the freshly-cloned BunString to JS. Diff<T> derives Copy, so the diff[idx] destructuring and diff[idx+1].value reads are sound.

I'm deferring rather than approving because this is a non-trivial native addition with a design choice (the trait abstraction) that a maintainer should glance at, not because I found anything wrong.

[robobun]

Picking this up. Pushed 3e228a3:

• Output::List and Output::Lines now carry lines / check_comma_disparity, and myers_diff takes &Output. This fixes the clippy (needless_pass_by_value) and mordant (bare_bool_args) findings on the first revision.
• Added tests for a line diff with UTF-16 on both sides (main prints + 32,32,115,..., an array of char codes, for any diff with emoji or CJK on both sides) and for the colored char diff with Latin-1, UTF-16 and mixed inputs (spawns a child with FORCE_COLOR=1). Removed the strictEqual("café", "caf😀") assertion, which took the short string path and never reached the diff.
• Dropped the stale Internal declarations in assertion_error.ts.

Verified: test/js/node/assert/assert.test.cjs has 3 tests that fail with main's src/ and pass here. test/js/node/assert/ (411 tests) and the 17 vendored test-assert*.js files pass. A 31 case differential script matches Node byte for byte with and without colors. Build 102537 (first revision) was green on all 179 jobs.

[claude]

I reviewed this and didn't find any bugs. Since it's a ~300-line native-code port introducing new rendering logic, traits, and encoding handling, a human look would still be worthwhile.

What was reviewed:

• render_simple/render_lines traced against the removed JS printSimpleMyersDiff/printMyersDiff — iteration order, nop-collapse thresholds, and the trimEnd-then-prepend-\n ordering all match.
• is_js_whitespace checked against the ECMAScript WhiteSpace + LineTerminator set used by String.prototype.trimEnd.
• Mixed-encoding widening (Latin-1 → UTF-16 via u16::from(b)) is byte-value-preserving for the Latin-1 range, so the U+FFFD fix is sound.
• colors_from_js reads from the internal util/colors module (not user-controlled), and falls back to empty on non-string — matches the no-color case.

Extended reasoning...

Overview

This PR moves printMyersDiff and printSimpleMyersDiff from src/js/internal/assert/myers_diff.ts into src/runtime/node/node_assert.rs, so the diff is rendered directly to a single JS string instead of round-tripping through a JS array of {kind, value} objects. It adds an Output enum to select the rendering shape, two new traits (CodeUnit, DiffText) to write generically over Latin-1/UTF-16, and two new host functions in node_assert_binding.rs. It also fixes a pre-existing encoding bug where mixed Latin-1/UTF-16 inputs were diffed over mismatched byte slices (or re-encoded to UTF-8 and later reinterpreted as Latin-1, producing U+FFFD). New tests in assert.test.cjs cover Latin-1, UTF-16, mixed-encoding, collapsed-run, and colored char-diff cases with expected messages captured from Node.

Security risks

None. This is error-message formatting for node:assert failures. Inputs are the util.inspect output of user values (strings), and the colors object is the internal internal/util/colors module. No parsing of untrusted external data, no filesystem/network, no auth/crypto.

Level of scrutiny

Medium. This is not a hot path (only runs when an assertion fails) and the blast radius of a bug is a slightly wrong diff message, not incorrect assertion results. But it is ~220 lines of new native rendering code with encoding-sensitive string handling, new trait abstractions, and a hand-rolled trimEnd whitespace matcher — the kind of port where an off-by-one or encoding mismatch is easy to miss. I traced the two render functions line-for-line against the removed JS and they match (including the nop_count == kNopLinesToCollapse + {1,2} special cases and the fact that the JS previousType && ... falsy-0 quirk only applied to Insert=0, which the Rust guard on Some(Equal) doesn't need to replicate). The trimEnd reimplementation preserves the leading \n via out.len() > 1, which mirrors JS building the message, calling .trimEnd(), then prepending \n.

Other factors

• Test coverage is solid: exact-string assertions against Node-captured output for both encodings, mixed encodings, the ... collapse path with skipped: true, and a subprocess test for the colored char-diff path (which only fires under FORCE_COLOR). The subprocess test drains stdout/stderr/exited concurrently and asserts stderr before exitCode.
• BunString::clone_latin1/clone_utf16 and transfer_to_js exist and have the expected signatures; Diff<T> is Copy so diff[idx] in render_lines is sound.
• The raw myersDiff list export is preserved for parity, and its argument reading was simplified (frame.argument(n).is_truthy() on missing args returns false, matching the old defaults).

Given the size and the new native abstractions, I'm deferring rather than approving outright, but I found nothing wrong.

[robobun]

^{Updated 3:28 AM PT - Aug 21st, 2026}

✅ @robobun, your commit 320783efff9bba739f7e0a5d7eaf88ff2ccf5cdc passed in Build #102556! 🎉

---

🧪   To try this PR locally:

bunx bun-pr 39924

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

bun-39924 --bun