Skip to content

Fix TOML compliance and pin TOML/YAML test suites to specific SHAs#576

Merged
frostney merged 3 commits into
mainfrom
t3code/890fa929
May 8, 2026
Merged

Fix TOML compliance and pin TOML/YAML test suites to specific SHAs#576
frostney merged 3 commits into
mainfrom
t3code/890fa929

Conversation

@frostney
Copy link
Copy Markdown
Owner

@frostney frostney commented May 8, 2026

Summary

  • Fix 6 toml-test 1.1.0 failures by adding a ValidateInput pre-scan to the TOML parser that strips UTF-8 BOM at file start and rejects forbidden control characters before parsing begins (Option C — input-level validation so every downstream consumer is protected).
  • Pin run_toml_test_suite.py and run_yaml_test_suite.py to specific upstream SHAs instead of cloning branch HEAD, matching the existing test262 pattern.
  • Add weekly cron workflows (toml-test-bump.yml, yaml-test-bump.yml) and bump scripts (toml-test-bump-pin.ts, yaml-test-bump-pin.ts) for both suites.
  • All three bump workflows (test262, toml-test, yaml-test) now use a fixed branch name (chore/<suite>-bump) so an unmerged PR is updated in place rather than replaced.
  • Add *.or and build/GocciaTOMLCheck to .gitignore to prevent build artifacts from being staged.

Testing

  • Verified no regressions and confirmed the new feature or bugfix in end-to-end JavaScript/TypeScript tests
  • Updated documentation
  • Optional: Verified no regressions and confirmed the new feature or bugfix in native Pascal tests (if AST, scope, evaluator, or value types changed)
  • Optional: Verified no benchmark regressions or confirmed benchmark coverage for the change

Add ValidateInput pre-scan to the TOML parser that strips a UTF-8 BOM
at file start and rejects forbidden control characters (U+0000–U+0008,
U+000B–U+000C, U+000E–U+001F, U+007F) before parsing begins.  This
fixes 6 upstream toml-test failures (4 false accepts for vertical tab
in bare values, 2 false rejects for BOM-prefixed files) without
affecting ECMAScript engine conformance.

Pin both run_toml_test_suite.py and run_yaml_test_suite.py to specific
upstream SHAs instead of cloning branch HEAD, matching the existing
test262 pattern.  Add weekly cron workflows and bump scripts for both
suites.  All three bump workflows now use a fixed branch name so an
unmerged PR is updated in place rather than replaced.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
@vercel
Copy link
Copy Markdown

vercel Bot commented May 8, 2026

The latest updates on your projects. Learn more about Vercel for GitHub.

1 Skipped Deployment
Project Deployment Actions Updated (UTC)
gocciascript-homepage Ignored Ignored Preview May 8, 2026 9:22am

Request Review

@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented May 8, 2026

Review Change Stack
No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info
⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: e92626af-dd74-4901-8ae1-ccbd9fe9d5f4

📥 Commits

Reviewing files that changed from the base of the PR and between 1d9f078 and d3cd7fb.

📒 Files selected for processing (10)
  • .github/workflows/test262-bump.yml
  • .github/workflows/toml-test-bump.yml
  • .github/workflows/yaml-test-bump.yml
  • .gitignore
  • docs/build-system.md
  • docs/testing.md
  • scripts/run_toml_test_suite.py
  • scripts/run_yaml_test_suite.py
  • scripts/suite-bump-pin.ts
  • source/units/Goccia.TOML.pas

📝 Walkthrough

Walkthrough

This PR establishes automated weekly pinning of test suite SHAs across test262, toml-test, and yaml-test-suite. It introduces a shared Bun utility script, updates Python test runners to use SHA-based checkouts, adds three CI workflows (test262-bump, toml-test-bump, yaml-test-bump), enhances TOML parser input validation, and documents the new automation. Configuration and documentation updates reflect these infrastructure changes.

Changes

Test Suite Automation and TOML Parser Enhancement

Layer / File(s) Summary
Suite SHA Update Utility
scripts/suite-bump-pin.ts
New Bun/TypeScript script validates 40-hex SHA format, reads target files, globally replaces SUITE_SHA assignments, and conditionally writes updates with appropriate exit codes.
Test Suite Runner Configuration
scripts/run_toml_test_suite.py, scripts/run_yaml_test_suite.py
Both scripts switch from branch-based git clone to SHA-pinned shallow git fetch and git checkout, introducing SUITE_SHA constants and replacing branch references.
CI Automation Workflows
.github/workflows/test262-bump.yml, .github/workflows/toml-test-bump.yml, .github/workflows/yaml-test-bump.yml
Three workflows (test262-bump, toml-test-bump, yaml-test-bump) run weekly or on manual dispatch, query latest upstream SHAs via GitHub API, invoke suite-bump-pin script, detect changes, and conditionally create/update PRs with automated labels.
TOML Parser Input Preparation
source/units/Goccia.TOML.pas
New private PrepareInput method strips UTF-8 BOM and validates absence of forbidden control characters before document parsing; integrated into ParseDocument after reset.
Configuration and Documentation
.gitignore, docs/build-system.md, docs/testing.md
.gitignore entries added for *.or files and build output; documentation clarified regarding SHA pinning in test scripts and new weekly automation workflows with schedules.

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

Possibly related PRs

  • frostney/GocciaScript#248: Both PRs touch GitHub CI configuration, introduce the spec compliance label, and adjust workflow permissions for pull-requests.

Suggested labels

spec compliance, internal

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 warning)

Check name Status Explanation Resolution
Docstring Coverage ⚠️ Warning Docstring coverage is 0.00% which is insufficient. The required threshold is 80.00%. Write docstrings for the functions missing them to satisfy the coverage threshold.
✅ Passed checks (4 passed)
Check name Status Explanation
Title check ✅ Passed The title accurately summarizes the main changes: fixing TOML compliance and pinning test suites to specific SHAs, which are the primary objectives.
Description check ✅ Passed The description covers all required template sections with specifics: clear summary of changes with issue references, and testing verification with appropriate checkmarks and explanations.
Linked Issues check ✅ Passed Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check ✅ Passed Check skipped because no linked issues were found for this pull request.

✏️ Tip: You can configure your own custom pre-merge checks in the settings.


Comment @coderabbitai help to get the list of available commands and usage tips.

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented May 8, 2026

Suite Timing

Test Runner (interpreted: 8,914 passed; bytecode: 8,914 passed)
Metric Interpreted Bytecode
Total 8914 8914
Passed 8914 ✅ 8914 ✅
Workers 4 4
Test Duration 1.90s 1.50s
Lex (cumulative) 258.8ms 116.1ms
Parse (cumulative) 270.6ms 192.4ms
Compile (cumulative) 391.2ms
Execute (cumulative) 1.74s 1.44s
Engine Total (cumulative) 2.27s 2.14s
Lex (avg/worker) 64.7ms 29.0ms
Parse (avg/worker) 67.6ms 48.1ms
Compile (avg/worker) 97.8ms
Execute (avg/worker) 434.1ms 359.7ms
Engine Total (avg/worker) 566.4ms 534.6ms

Memory

GC rows aggregate the main thread plus all worker thread-local GCs. Test runner worker shutdown frees thread-local heaps in bulk; that shutdown reclamation is not counted as GC collections or collected objects.

Metric Interpreted Bytecode
GC Live 215.28 MiB 209.86 MiB
GC Peak Live 215.29 MiB 209.87 MiB
GC Allocated During Run 219.08 MiB 213.65 MiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 1 1
GC Collected Objects 74 74
Heap Start Allocated 145.4 KiB 145.4 KiB
Heap End Allocated 1.37 MiB 1.37 MiB
Heap Delta Allocated 1.23 MiB 1.23 MiB
Heap Delta Free 469.3 KiB 469.3 KiB
Benchmarks (interpreted: 407; bytecode: 407)
Metric Interpreted Bytecode
Total 407 407
Workers 4 4
Duration 2.42min 2.33min

Memory

GC rows aggregate the main thread plus all worker thread-local GCs. Benchmark runner performs explicit between-file collections, so collection and collected-object counts can be much higher than the test runner.

Metric Interpreted Bytecode
GC Live 3.23 MiB 3.23 MiB
GC Peak Live 95.93 MiB 79.03 MiB
GC Allocated During Run 13.90 GiB 10.36 GiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 2,827 2,653
GC Collected Objects 259,533,990 248,547,164
Heap Start Allocated 1.13 MiB 1.13 MiB
Heap End Allocated 1.13 MiB 1.13 MiB
Heap Delta Allocated 128 B 128 B

Measured on ubuntu-latest x64.

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented May 8, 2026

Benchmark Results

407 benchmarks

Interpreted: 🟢 67 improved · 🔴 36 regressed · 304 unchanged · avg +0.8%
Bytecode: 🟢 244 improved · 🔴 28 regressed · 135 unchanged · avg +4.2%

arraybuffer.js — Interp: 🟢 1, 13 unch. · avg +2.1% · Bytecode: 🟢 6, 🔴 3, 5 unch. · avg +2.5%
Benchmark Interpreted Δ Bytecode Δ
create ArrayBuffer(0) 147,043 ops/sec [111,644..162,316] → 156,503 ops/sec [108,018..160,757] ~ overlap (+6.4%) 210,046 ops/sec [159,236..215,749] → 218,202 ops/sec [212,582..218,662] ~ overlap (+3.9%)
create ArrayBuffer(64) 154,461 ops/sec [145,194..157,160] → 152,788 ops/sec [151,132..159,499] ~ overlap (-1.1%) 201,824 ops/sec [200,742..204,966] → 207,363 ops/sec [205,771..209,570] 🟢 +2.7%
create ArrayBuffer(1024) 136,676 ops/sec [134,957..138,242] → 133,462 ops/sec [126,701..136,765] ~ overlap (-2.4%) 175,711 ops/sec [173,774..177,425] → 169,569 ops/sec [124,440..173,227] 🔴 -3.5%
create ArrayBuffer(8192) 76,875 ops/sec [76,244..77,596] → 78,206 ops/sec [76,780..79,219] ~ overlap (+1.7%) 98,490 ops/sec [98,047..99,182] → 83,465 ops/sec [82,995..84,028] 🔴 -15.3%
slice full buffer (64 bytes) 184,603 ops/sec [180,466..186,368] → 181,330 ops/sec [178,502..183,999] ~ overlap (-1.8%) 253,856 ops/sec [249,066..256,767] → 265,461 ops/sec [264,652..266,357] 🟢 +4.6%
slice half buffer (512 of 1024 bytes) 163,119 ops/sec [159,237..167,817] → 164,160 ops/sec [161,777..166,482] ~ overlap (+0.6%) 222,098 ops/sec [219,358..223,981] → 231,111 ops/sec [203,639..236,886] ~ overlap (+4.1%)
slice with negative indices 128,901 ops/sec [76,627..151,257] → 153,451 ops/sec [152,188..154,468] 🟢 +19.0% 233,295 ops/sec [228,101..241,036] → 246,815 ops/sec [244,394..248,921] 🟢 +5.8%
slice empty range 173,968 ops/sec [172,105..176,662] → 176,392 ops/sec [173,423..178,614] ~ overlap (+1.4%) 242,006 ops/sec [240,262..247,332] → 250,525 ops/sec [243,006..257,536] ~ overlap (+3.5%)
byteLength access 397,295 ops/sec [385,993..400,711] → 406,447 ops/sec [398,986..412,136] ~ overlap (+2.3%) 476,322 ops/sec [473,603..478,324] → 515,546 ops/sec [509,126..520,671] 🟢 +8.2%
Symbol.toStringTag access 329,785 ops/sec [329,022..330,415] → 329,632 ops/sec [318,172..334,268] ~ overlap (-0.0%) 342,659 ops/sec [339,234..347,746] → 381,195 ops/sec [377,896..385,718] 🟢 +11.2%
ArrayBuffer.isView 239,087 ops/sec [235,877..240,545] → 241,574 ops/sec [236,206..242,072] ~ overlap (+1.0%) 316,921 ops/sec [315,763..317,610] → 348,367 ops/sec [342,370..351,322] 🟢 +9.9%
clone ArrayBuffer(64) 163,642 ops/sec [163,395..164,439] → 164,771 ops/sec [160,315..165,920] ~ overlap (+0.7%) 223,354 ops/sec [220,694..223,939] → 229,770 ops/sec [223,077..231,606] ~ overlap (+2.9%)
clone ArrayBuffer(1024) 140,844 ops/sec [138,493..143,399] → 142,218 ops/sec [141,287..143,494] ~ overlap (+1.0%) 191,749 ops/sec [188,814..194,049] → 185,519 ops/sec [185,337..187,953] 🔴 -3.2%
clone ArrayBuffer inside object 116,435 ops/sec [113,162..117,239] → 116,623 ops/sec [113,868..117,385] ~ overlap (+0.2%) 148,698 ops/sec [146,576..149,847] → 149,501 ops/sec [146,971..152,972] ~ overlap (+0.5%)
arrays.js — Interp: 🟢 2, 17 unch. · avg +0.6% · Bytecode: 🟢 10, 9 unch. · avg +4.4%
Benchmark Interpreted Δ Bytecode Δ
Array.from length 100 3,798 ops/sec [3,779..3,824] → 3,612 ops/sec [3,229..3,803] ~ overlap (-4.9%) 6,308 ops/sec [6,168..6,310] → 6,955 ops/sec [6,292..7,057] ~ overlap (+10.3%)
Array.from 10 elements 86,881 ops/sec [86,664..87,408] → 89,138 ops/sec [88,007..89,282] 🟢 +2.6% 97,823 ops/sec [97,171..97,947] → 104,006 ops/sec [101,829..104,497] 🟢 +6.3%
Array.of 10 elements 105,100 ops/sec [103,543..107,309] → 105,697 ops/sec [88,830..107,896] ~ overlap (+0.6%) 124,450 ops/sec [123,840..124,743] → 132,593 ops/sec [131,999..133,450] 🟢 +6.5%
spread into new array 130,216 ops/sec [127,186..133,009] → 130,969 ops/sec [129,679..132,431] ~ overlap (+0.6%) 80,465 ops/sec [79,954..81,319] → 78,754 ops/sec [75,529..82,088] ~ overlap (-2.1%)
map over 50 elements 6,420 ops/sec [6,355..6,569] → 6,417 ops/sec [6,363..6,511] ~ overlap (-0.0%) 12,377 ops/sec [12,284..12,427] → 12,760 ops/sec [12,375..13,001] ~ overlap (+3.1%)
filter over 50 elements 6,226 ops/sec [6,039..6,286] → 6,237 ops/sec [6,182..6,294] ~ overlap (+0.2%) 12,163 ops/sec [12,066..12,356] → 12,303 ops/sec [11,127..13,075] ~ overlap (+1.1%)
reduce sum 50 elements 6,747 ops/sec [6,594..6,784] → 6,993 ops/sec [6,790..7,034] 🟢 +3.6% 11,541 ops/sec [11,405..11,607] → 12,446 ops/sec [12,395..12,540] 🟢 +7.8%
forEach over 50 elements 6,002 ops/sec [5,852..6,055] → 6,040 ops/sec [5,942..6,242] ~ overlap (+0.6%) 12,599 ops/sec [12,418..12,635] → 13,337 ops/sec [12,280..14,529] ~ overlap (+5.9%)
find in 50 elements 8,939 ops/sec [8,360..9,061] → 8,829 ops/sec [8,746..8,877] ~ overlap (-1.2%) 17,578 ops/sec [17,224..17,727] → 18,343 ops/sec [18,176..18,624] 🟢 +4.4%
sort 20 elements 3,341 ops/sec [3,261..3,480] → 3,371 ops/sec [3,350..3,379] ~ overlap (+0.9%) 6,680 ops/sec [6,600..6,710] → 7,259 ops/sec [7,134..7,437] 🟢 +8.7%
flat nested array 45,680 ops/sec [44,526..46,243] → 46,219 ops/sec [45,925..46,777] ~ overlap (+1.2%) 53,423 ops/sec [52,336..54,481] → 52,935 ops/sec [52,609..54,218] ~ overlap (-0.9%)
flatMap 26,431 ops/sec [25,956..26,689] → 26,580 ops/sec [26,371..26,922] ~ overlap (+0.6%) 35,660 ops/sec [35,339..36,199] → 35,565 ops/sec [34,946..36,493] ~ overlap (-0.3%)
map inside map (5x5) 6,893 ops/sec [6,772..6,979] → 7,073 ops/sec [6,964..7,113] ~ overlap (+2.6%) 10,325 ops/sec [10,255..10,449] → 10,564 ops/sec [10,362..10,803] ~ overlap (+2.3%)
filter inside map (5x10) 4,900 ops/sec [4,680..4,943] → 4,872 ops/sec [4,804..5,013] ~ overlap (-0.6%) 8,298 ops/sec [8,178..8,362] → 8,524 ops/sec [8,366..8,698] 🟢 +2.7%
reduce inside map (5x10) 5,361 ops/sec [5,232..5,392] → 5,454 ops/sec [5,307..5,509] ~ overlap (+1.7%) 8,914 ops/sec [8,861..9,020] → 9,475 ops/sec [9,307..9,631] 🟢 +6.3%
forEach inside forEach (5x10) 4,801 ops/sec [4,717..4,842] → 4,759 ops/sec [4,734..4,831] ~ overlap (-0.9%) 9,695 ops/sec [9,664..9,792] → 10,111 ops/sec [10,025..10,153] 🟢 +4.3%
find inside some (10x10) 3,944 ops/sec [3,894..4,086] → 4,026 ops/sec [3,999..4,046] ~ overlap (+2.1%) 7,310 ops/sec [7,267..7,371] → 7,964 ops/sec [7,882..7,999] 🟢 +8.9%
map+filter chain nested (5x20) 1,514 ops/sec [1,509..1,541] → 1,530 ops/sec [1,512..1,555] ~ overlap (+1.0%) 2,655 ops/sec [2,643..2,670] → 2,881 ops/sec [2,866..2,897] 🟢 +8.5%
reduce flatten (10x5) 16,293 ops/sec [16,048..16,454] → 16,366 ops/sec [16,269..16,458] ~ overlap (+0.4%) 7,658 ops/sec [7,558..7,703] → 7,572 ops/sec [7,400..7,852] ~ overlap (-1.1%)
async-await.js — Interp: 6 unch. · avg +1.0% · Bytecode: 🟢 3, 3 unch. · avg +2.7%
Benchmark Interpreted Δ Bytecode Δ
single await 136,636 ops/sec [113,201..140,082] → 140,005 ops/sec [125,717..143,009] ~ overlap (+2.5%) 162,167 ops/sec [157,783..164,597] → 169,174 ops/sec [155,240..170,091] ~ overlap (+4.3%)
multiple awaits 66,491 ops/sec [64,860..67,778] → 67,052 ops/sec [65,849..67,631] ~ overlap (+0.8%) 69,908 ops/sec [69,631..69,964] → 73,628 ops/sec [73,012..74,419] 🟢 +5.3%
await non-Promise value 264,615 ops/sec [261,195..264,707] → 272,966 ops/sec [264,150..274,669] ~ overlap (+3.2%) 436,841 ops/sec [433,352..442,870] → 433,072 ops/sec [393,966..443,700] ~ overlap (-0.9%)
await with try/catch 113,904 ops/sec [111,716..114,238] → 113,679 ops/sec [113,116..114,209] ~ overlap (-0.2%) 157,605 ops/sec [157,123..158,909] → 161,690 ops/sec [160,274..162,085] 🟢 +2.6%
await Promise.all 22,186 ops/sec [21,852..23,270] → 22,234 ops/sec [22,020..22,561] ~ overlap (+0.2%) 23,585 ops/sec [23,417..23,804] → 24,066 ops/sec [23,821..24,151] 🟢 +2.0%
nested async function call 72,819 ops/sec [72,259..73,243] → 72,652 ops/sec [72,155..73,300] ~ overlap (-0.2%) 97,094 ops/sec [66,077..99,601] → 99,967 ops/sec [93,762..103,427] ~ overlap (+3.0%)
async-generators.js — Interp: 2 unch. · avg +0.4% · Bytecode: 2 unch. · avg +0.4%
Benchmark Interpreted Δ Bytecode Δ
for-await-of over async generator 2,227 ops/sec [1,927..2,338] → 2,281 ops/sec [2,008..2,332] ~ overlap (+2.4%) 2,860 ops/sec [2,348..2,879] → 2,883 ops/sec [2,743..2,890] ~ overlap (+0.8%)
async generator with await in body 20,823 ops/sec [20,725..21,009] → 20,472 ops/sec [19,600..20,840] ~ overlap (-1.7%) 24,351 ops/sec [23,901..24,665] → 24,370 ops/sec [23,024..24,682] ~ overlap (+0.1%)
base64.js — Interp: 🔴 1, 9 unch. · avg -0.6% · Bytecode: 🟢 6, 🔴 1, 3 unch. · avg +3.0%
Benchmark Interpreted Δ Bytecode Δ
short ASCII (13 chars) 3,656 ops/sec [3,607..3,720] → 3,628 ops/sec [3,593..3,659] ~ overlap (-0.8%) 4,088 ops/sec [4,048..4,147] → 4,026 ops/sec [3,990..4,035] 🔴 -1.5%
medium ASCII (450 chars) 136 ops/sec [129..144] → 138 ops/sec [136..144] ~ overlap (+1.3%) 150 ops/sec [135..152] → 152 ops/sec [148..155] ~ overlap (+1.0%)
Latin-1 characters 5,269 ops/sec [5,242..5,281] → 5,285 ops/sec [5,266..5,303] ~ overlap (+0.3%) 5,832 ops/sec [5,715..5,954] → 6,025 ops/sec [5,208..6,095] ~ overlap (+3.3%)
short base64 (20 chars) 2,285 ops/sec [1,446..2,334] → 2,284 ops/sec [2,281..2,312] ~ overlap (-0.0%) 2,455 ops/sec [2,413..2,476] → 2,541 ops/sec [2,512..2,560] 🟢 +3.5%
medium base64 (600 chars) 97 ops/sec [96..99] → 95 ops/sec [94..97] ~ overlap (-1.4%) 101 ops/sec [100..102] → 106 ops/sec [106..107] 🟢 +4.9%
Latin-1 output 3,290 ops/sec [3,254..3,330] → 3,243 ops/sec [3,209..3,276] ~ overlap (-1.4%) 3,519 ops/sec [3,487..3,583] → 3,704 ops/sec [3,685..3,723] 🟢 +5.2%
forgiving (no padding) 4,877 ops/sec [4,856..4,904] → 4,893 ops/sec [4,784..4,898] ~ overlap (+0.3%) 5,188 ops/sec [5,161..5,221] → 5,498 ops/sec [5,480..5,516] 🟢 +6.0%
with whitespace 2,123 ops/sec [2,081..2,144] → 2,058 ops/sec [2,052..2,060] 🔴 -3.1% 2,240 ops/sec [2,216..2,257] → 2,308 ops/sec [2,299..2,330] 🟢 +3.0%
atob(btoa(short)) 1,442 ops/sec [1,436..1,450] → 1,431 ops/sec [1,417..1,441] ~ overlap (-0.8%) 1,549 ops/sec [1,534..1,554] → 1,575 ops/sec [1,571..1,577] 🟢 +1.7%
atob(btoa(medium)) 57 ops/sec [56..58] → 56 ops/sec [56..57] ~ overlap (-0.9%) 60 ops/sec [60..61] → 62 ops/sec [58..64] ~ overlap (+2.5%)
classes.js — Interp: 🟢 4, 🔴 1, 26 unch. · avg +1.1% · Bytecode: 🟢 15, 16 unch. · avg +2.9%
Benchmark Interpreted Δ Bytecode Δ
simple class new 49,353 ops/sec [37,970..52,543] → 52,318 ops/sec [51,767..52,644] ~ overlap (+6.0%) 71,808 ops/sec [71,087..72,810] → 73,274 ops/sec [68,013..74,286] ~ overlap (+2.0%)
class with defaults 43,452 ops/sec [42,943..43,586] → 42,592 ops/sec [41,625..43,170] ~ overlap (-2.0%) 50,470 ops/sec [49,456..50,749] → 53,212 ops/sec [52,192..53,873] 🟢 +5.4%
50 instances via Array.from 1,954 ops/sec [1,945..1,963] → 1,897 ops/sec [1,822..1,937] 🔴 -2.9% 2,709 ops/sec [2,697..2,720] → 2,856 ops/sec [2,839..2,898] 🟢 +5.4%
instance method call 25,559 ops/sec [25,386..25,681] → 25,121 ops/sec [24,922..25,445] ~ overlap (-1.7%) 34,535 ops/sec [34,213..34,677] → 37,435 ops/sec [37,046..38,033] 🟢 +8.4%
static method call 41,088 ops/sec [39,949..41,418] → 40,642 ops/sec [40,251..40,761] ~ overlap (-1.1%) 72,505 ops/sec [72,235..72,813] → 75,063 ops/sec [73,726..75,667] 🟢 +3.5%
single-level inheritance 20,861 ops/sec [20,510..21,292] → 21,222 ops/sec [21,018..21,322] ~ overlap (+1.7%) 27,353 ops/sec [27,135..27,698] → 28,329 ops/sec [28,146..28,524] 🟢 +3.6%
two-level inheritance 18,384 ops/sec [18,196..18,574] → 18,451 ops/sec [18,398..18,577] ~ overlap (+0.4%) 22,058 ops/sec [21,632..22,286] → 22,392 ops/sec [22,291..22,625] 🟢 +1.5%
private field access 28,434 ops/sec [28,329..28,502] → 28,574 ops/sec [28,416..28,941] ~ overlap (+0.5%) 24,631 ops/sec [24,451..24,857] → 26,340 ops/sec [26,086..26,504] 🟢 +6.9%
private methods 31,364 ops/sec [31,001..31,594] → 31,379 ops/sec [31,353..31,569] ~ overlap (+0.0%) 28,434 ops/sec [27,755..28,611] → 30,377 ops/sec [30,171..30,708] 🟢 +6.8%
getter/setter access 28,700 ops/sec [28,507..28,834] → 28,905 ops/sec [28,636..29,208] ~ overlap (+0.7%) 40,011 ops/sec [39,539..40,329] → 41,142 ops/sec [40,521..41,487] 🟢 +2.8%
class decorator (identity) 39,175 ops/sec [38,393..39,672] → 39,248 ops/sec [38,821..39,974] ~ overlap (+0.2%) 45,266 ops/sec [43,551..45,882] → 46,861 ops/sec [45,912..47,427] 🟢 +3.5%
class decorator (wrapping) 22,578 ops/sec [22,275..23,391] → 22,856 ops/sec [22,829..22,897] ~ overlap (+1.2%) 24,629 ops/sec [24,451..25,012] → 24,522 ops/sec [24,045..24,892] ~ overlap (-0.4%)
identity method decorator 29,057 ops/sec [28,808..29,368] → 29,173 ops/sec [29,085..29,624] ~ overlap (+0.4%) 38,683 ops/sec [37,905..40,660] → 38,373 ops/sec [37,289..40,269] ~ overlap (-0.8%)
wrapping method decorator 23,584 ops/sec [23,464..23,716] → 23,417 ops/sec [23,304..23,733] ~ overlap (-0.7%) 29,721 ops/sec [28,724..30,613] → 28,712 ops/sec [27,999..29,895] ~ overlap (-3.4%)
stacked method decorators (x3) 15,982 ops/sec [15,592..16,773] → 16,365 ops/sec [10,163..16,573] ~ overlap (+2.4%) 20,529 ops/sec [19,980..21,194] → 21,284 ops/sec [20,337..21,967] ~ overlap (+3.7%)
identity field decorator 32,123 ops/sec [31,877..32,790] → 32,533 ops/sec [31,600..33,558] ~ overlap (+1.3%) 35,763 ops/sec [34,983..36,595] → 36,879 ops/sec [35,480..37,613] ~ overlap (+3.1%)
field initializer decorator 26,928 ops/sec [26,418..27,501] → 26,928 ops/sec [26,644..27,328] ~ overlap (+0.0%) 31,006 ops/sec [29,549..32,482] → 32,987 ops/sec [32,001..35,392] ~ overlap (+6.4%)
getter decorator (identity) 29,163 ops/sec [29,131..29,184] → 29,466 ops/sec [28,775..29,886] ~ overlap (+1.0%) 29,296 ops/sec [29,186..29,451] → 30,058 ops/sec [29,974..30,929] 🟢 +2.6%
setter decorator (identity) 23,875 ops/sec [23,588..24,109] → 24,683 ops/sec [24,316..24,996] 🟢 +3.4% 23,970 ops/sec [23,851..24,132] → 25,543 ops/sec [25,230..26,016] 🟢 +6.6%
static method decorator 30,812 ops/sec [29,952..31,438] → 31,507 ops/sec [31,174..31,672] ~ overlap (+2.3%) 37,547 ops/sec [37,111..39,367] → 40,051 ops/sec [38,925..41,010] ~ overlap (+6.7%)
static field decorator 36,621 ops/sec [36,192..36,662] → 38,611 ops/sec [37,447..38,806] 🟢 +5.4% 42,954 ops/sec [40,340..44,392] → 41,638 ops/sec [36,677..44,361] ~ overlap (-3.1%)
private method decorator 24,029 ops/sec [23,780..25,045] → 24,405 ops/sec [24,248..24,462] ~ overlap (+1.6%) 31,131 ops/sec [30,592..31,648] → 30,209 ops/sec [29,745..31,056] ~ overlap (-3.0%)
private field decorator 26,815 ops/sec [26,380..27,495] → 27,313 ops/sec [26,885..27,780] ~ overlap (+1.9%) 25,774 ops/sec [25,120..26,242] → 26,676 ops/sec [26,032..27,021] ~ overlap (+3.5%)
plain auto-accessor (no decorator) 45,567 ops/sec [44,544..46,541] → 45,980 ops/sec [42,224..47,326] ~ overlap (+0.9%) 43,489 ops/sec [41,939..46,228] → 43,290 ops/sec [42,455..44,665] ~ overlap (-0.5%)
auto-accessor with decorator 25,877 ops/sec [25,593..26,973] → 26,547 ops/sec [25,601..26,983] ~ overlap (+2.6%) 26,748 ops/sec [25,482..27,893] → 27,466 ops/sec [27,012..28,662] ~ overlap (+2.7%)
decorator writing metadata 20,685 ops/sec [20,464..21,038] → 20,984 ops/sec [20,912..21,222] ~ overlap (+1.4%) 24,481 ops/sec [23,963..25,210] → 24,888 ops/sec [24,469..25,626] ~ overlap (+1.7%)
static getter read 53,614 ops/sec [53,053..54,121] → 53,532 ops/sec [52,389..54,150] ~ overlap (-0.2%) 70,094 ops/sec [67,793..71,542] → 72,336 ops/sec [70,784..73,490] ~ overlap (+3.2%)
static getter/setter pair 39,145 ops/sec [38,750..39,395] → 38,709 ops/sec [38,242..39,460] ~ overlap (-1.1%) 50,341 ops/sec [49,692..51,997] → 53,087 ops/sec [52,137..53,624] 🟢 +5.5%
inherited static getter 31,696 ops/sec [31,313..32,154] → 32,857 ops/sec [32,755..33,043] 🟢 +3.7% 39,045 ops/sec [38,748..39,162] → 39,956 ops/sec [39,569..40,604] 🟢 +2.3%
inherited static setter 34,414 ops/sec [33,800..34,543] → 35,262 ops/sec [34,586..35,536] 🟢 +2.5% 41,503 ops/sec [41,238..41,721] → 42,488 ops/sec [42,085..43,030] 🟢 +2.4%
inherited static getter with this binding 28,031 ops/sec [27,644..28,135] → 28,547 ops/sec [28,070..28,684] ~ overlap (+1.8%) 34,853 ops/sec [34,515..35,195] → 35,090 ops/sec [34,859..35,589] ~ overlap (+0.7%)
closures.js — Interp: 🔴 1, 10 unch. · avg -1.7% · Bytecode: 🟢 10, 1 unch. · avg +8.6%
Benchmark Interpreted Δ Bytecode Δ
closure over single variable 43,510 ops/sec [42,435..44,269] → 43,798 ops/sec [42,738..43,816] ~ overlap (+0.7%) 153,867 ops/sec [151,761..154,495] → 167,643 ops/sec [162,106..169,367] 🟢 +9.0%
closure over multiple variables 44,241 ops/sec [43,500..44,789] → 44,313 ops/sec [43,401..44,492] ~ overlap (+0.2%) 134,844 ops/sec [132,532..136,254] → 146,023 ops/sec [143,215..148,490] 🟢 +8.3%
nested closures 48,930 ops/sec [48,589..49,210] → 48,812 ops/sec [46,427..49,421] ~ overlap (-0.2%) 139,138 ops/sec [138,585..139,554] → 146,267 ops/sec [142,023..149,996] 🟢 +5.1%
function as argument 32,909 ops/sec [32,210..32,993] → 32,614 ops/sec [32,262..33,247] ~ overlap (-0.9%) 143,186 ops/sec [140,214..145,920] → 154,722 ops/sec [153,479..158,565] 🟢 +8.1%
function returning function 42,625 ops/sec [42,234..43,572] → 42,304 ops/sec [41,794..42,491] ~ overlap (-0.8%) 164,796 ops/sec [161,589..166,828] → 166,986 ops/sec [140,143..173,374] ~ overlap (+1.3%)
compose two functions 25,911 ops/sec [25,594..26,055] → 25,795 ops/sec [25,368..26,391] ~ overlap (-0.4%) 91,135 ops/sec [90,192..91,335] → 100,877 ops/sec [98,128..106,113] 🟢 +10.7%
fn.call 59,641 ops/sec [59,209..59,727] → 58,414 ops/sec [57,996..58,766] 🔴 -2.1% 92,741 ops/sec [91,499..93,593] → 101,802 ops/sec [99,691..103,120] 🟢 +9.8%
fn.apply 47,308 ops/sec [47,137..47,445] → 46,750 ops/sec [46,328..47,204] ~ overlap (-1.2%) 95,460 ops/sec [94,961..95,782] → 97,560 ops/sec [96,520..99,212] 🟢 +2.2%
fn.bind 56,701 ops/sec [55,861..58,465] → 55,568 ops/sec [54,557..56,543] ~ overlap (-2.0%) 166,102 ops/sec [164,328..166,775] → 173,882 ops/sec [172,096..177,073] 🟢 +4.7%
recursive sum to 50 3,742 ops/sec [3,660..3,836] → 3,735 ops/sec [3,659..3,767] ~ overlap (-0.2%) 18,285 ops/sec [18,157..18,308] → 21,652 ops/sec [21,418..21,814] 🟢 +18.4%
recursive tree traversal 7,241 ops/sec [7,051..7,380] → 6,402 ops/sec [5,074..7,240] ~ overlap (-11.6%) 18,052 ops/sec [17,884..18,294] → 21,175 ops/sec [20,765..21,475] 🟢 +17.3%
collections.js — Interp: 🟢 1, 11 unch. · avg +0.4% · Bytecode: 🟢 10, 2 unch. · avg +5.8%
Benchmark Interpreted Δ Bytecode Δ
add 50 elements 3,057 ops/sec [3,040..3,079] → 3,067 ops/sec [3,040..3,093] ~ overlap (+0.3%) 3,866 ops/sec [3,801..3,971] → 4,080 ops/sec [4,039..4,104] 🟢 +5.5%
has lookup (50 elements) 45,467 ops/sec [45,212..46,812] → 45,843 ops/sec [45,118..46,674] ~ overlap (+0.8%) 57,442 ops/sec [56,513..57,702] → 58,708 ops/sec [58,401..59,073] 🟢 +2.2%
delete elements 24,653 ops/sec [24,454..25,044] → 25,009 ops/sec [24,894..25,198] ~ overlap (+1.4%) 29,456 ops/sec [29,042..29,667] → 30,570 ops/sec [30,369..30,982] 🟢 +3.8%
forEach iteration 5,013 ops/sec [4,842..5,245] → 5,222 ops/sec [5,186..5,256] ~ overlap (+4.2%) 9,181 ops/sec [9,015..9,257] → 10,179 ops/sec [9,981..10,280] 🟢 +10.9%
spread to array 15,761 ops/sec [15,511..15,874] → 15,804 ops/sec [15,725..16,242] ~ overlap (+0.3%) 109,923 ops/sec [109,163..111,075] → 112,267 ops/sec [94,551..114,792] ~ overlap (+2.1%)
deduplicate array 20,797 ops/sec [20,264..21,252] → 20,967 ops/sec [20,546..21,335] ~ overlap (+0.8%) 38,546 ops/sec [38,266..38,801] → 40,058 ops/sec [39,597..40,498] 🟢 +3.9%
set 50 entries 2,291 ops/sec [2,273..2,301] → 2,330 ops/sec [2,305..2,353] 🟢 +1.7% 2,993 ops/sec [2,956..3,020] → 3,129 ops/sec [3,045..3,220] 🟢 +4.5%
get lookup (50 entries) 46,271 ops/sec [45,772..46,703] → 45,868 ops/sec [45,049..46,325] ~ overlap (-0.9%) 51,977 ops/sec [51,631..52,433] → 54,356 ops/sec [53,750..57,215] 🟢 +4.6%
has check 66,374 ops/sec [65,539..67,145] → 65,819 ops/sec [65,467..65,951] ~ overlap (-0.8%) 75,946 ops/sec [75,510..76,676] → 81,415 ops/sec [79,407..82,939] 🟢 +7.2%
delete entries 25,740 ops/sec [25,094..26,038] → 25,121 ops/sec [24,869..25,211] ~ overlap (-2.4%) 27,607 ops/sec [27,535..28,036] → 29,801 ops/sec [28,763..30,195] 🟢 +7.9%
forEach iteration 5,092 ops/sec [5,072..5,163] → 5,158 ops/sec [5,059..5,173] ~ overlap (+1.3%) 9,242 ops/sec [9,117..9,315] → 10,564 ops/sec [10,230..11,264] 🟢 +14.3%
keys/values/entries 4,402 ops/sec [4,229..4,441] → 4,338 ops/sec [4,310..4,392] ~ overlap (-1.5%) 14,874 ops/sec [14,682..15,352] → 15,194 ops/sec [14,867..15,406] ~ overlap (+2.2%)
csv.js — Interp: 13 unch. · avg -0.2% · Bytecode: 🟢 10, 3 unch. · avg +6.9%
Benchmark Interpreted Δ Bytecode Δ
parse simple 3-column CSV 46,074 ops/sec [45,507..46,441] → 44,178 ops/sec [26,657..48,428] ~ overlap (-4.1%) 49,404 ops/sec [48,922..49,739] → 53,237 ops/sec [51,274..53,889] 🟢 +7.8%
parse 10-row CSV 13,198 ops/sec [13,118..13,303] → 13,249 ops/sec [13,008..13,481] ~ overlap (+0.4%) 13,363 ops/sec [13,151..13,489] → 15,168 ops/sec [15,076..15,202] 🟢 +13.5%
parse 100-row CSV 2,029 ops/sec [2,002..2,046] → 2,038 ops/sec [2,015..2,068] ~ overlap (+0.5%) 2,155 ops/sec [2,123..2,187] → 2,243 ops/sec [2,233..2,251] 🟢 +4.1%
parse CSV with quoted fields 68,272 ops/sec [67,637..70,474] → 67,925 ops/sec [67,697..68,214] ~ overlap (-0.5%) 74,090 ops/sec [72,837..75,494] → 78,168 ops/sec [77,166..78,517] 🟢 +5.5%
parse without headers (array of arrays) 5,701 ops/sec [5,532..5,758] → 5,657 ops/sec [5,457..5,712] ~ overlap (-0.8%) 6,115 ops/sec [6,063..6,230] → 6,403 ops/sec [6,186..6,443] ~ overlap (+4.7%)
parse with semicolon delimiter 9,420 ops/sec [9,261..9,672] → 9,709 ops/sec [9,305..9,802] ~ overlap (+3.1%) 10,353 ops/sec [10,287..10,396] → 10,586 ops/sec [10,478..10,679] 🟢 +2.2%
stringify array of objects 66,481 ops/sec [64,865..67,453] → 66,147 ops/sec [65,163..67,210] ~ overlap (-0.5%) 70,020 ops/sec [69,045..70,958] → 77,387 ops/sec [77,364..77,465] 🟢 +10.5%
stringify array of arrays 23,921 ops/sec [23,809..24,029] → 24,148 ops/sec [23,823..24,405] ~ overlap (+1.0%) 23,930 ops/sec [23,545..24,026] → 27,008 ops/sec [26,820..27,127] 🟢 +12.9%
stringify with values needing escaping 48,774 ops/sec [48,214..49,748] → 48,573 ops/sec [47,401..49,304] ~ overlap (-0.4%) 52,959 ops/sec [52,159..53,618] → 57,090 ops/sec [55,919..57,469] 🟢 +7.8%
reviver converts numbers 1,313 ops/sec [1,301..1,334] → 1,314 ops/sec [1,282..1,323] ~ overlap (+0.1%) 1,621 ops/sec [1,594..1,633] → 1,626 ops/sec [1,606..1,643] ~ overlap (+0.3%)
reviver filters empty to null 10,676 ops/sec [10,579..10,710] → 10,627 ops/sec [10,420..10,837] ~ overlap (-0.5%) 13,594 ops/sec [13,364..14,373] → 14,319 ops/sec [14,192..14,465] ~ overlap (+5.3%)
parse then stringify 8,490 ops/sec [8,314..8,543] → 8,466 ops/sec [8,190..8,645] ~ overlap (-0.3%) 8,501 ops/sec [8,311..8,611] → 9,179 ops/sec [9,079..9,306] 🟢 +8.0%
stringify then parse 8,141 ops/sec [7,955..8,275] → 8,069 ops/sec [8,009..8,295] ~ overlap (-0.9%) 8,381 ops/sec [8,296..8,503] → 8,980 ops/sec [8,808..9,036] 🟢 +7.1%
destructuring.js — Interp: 🟢 1, 🔴 1, 20 unch. · avg -0.0% · Bytecode: 🟢 9, 🔴 1, 12 unch. · avg +2.9%
Benchmark Interpreted Δ Bytecode Δ
simple array destructuring 164,820 ops/sec [162,076..166,948] → 165,684 ops/sec [164,415..167,730] ~ overlap (+0.5%) 121,973 ops/sec [121,139..123,203] → 122,630 ops/sec [119,250..124,488] ~ overlap (+0.5%)
with rest element 112,628 ops/sec [108,855..115,061] → 112,727 ops/sec [111,135..113,489] ~ overlap (+0.1%) 90,375 ops/sec [82,340..91,152] → 91,581 ops/sec [90,679..93,009] ~ overlap (+1.3%)
with defaults 164,470 ops/sec [163,527..164,867] → 165,464 ops/sec [162,771..165,837] ~ overlap (+0.6%) 127,877 ops/sec [126,281..129,233] → 129,110 ops/sec [110,755..131,945] ~ overlap (+1.0%)
skip elements 175,787 ops/sec [174,331..177,628] → 175,204 ops/sec [174,007..176,298] ~ overlap (-0.3%) 132,748 ops/sec [131,412..133,289] → 134,356 ops/sec [131,907..140,498] ~ overlap (+1.2%)
nested array destructuring 83,442 ops/sec [82,925..85,382] → 82,462 ops/sec [80,708..83,722] ~ overlap (-1.2%) 44,978 ops/sec [44,809..45,148] → 44,781 ops/sec [44,183..46,479] ~ overlap (-0.4%)
swap variables 196,274 ops/sec [195,223..197,496] → 198,667 ops/sec [196,830..201,280] ~ overlap (+1.2%) 159,008 ops/sec [157,752..161,453] → 161,695 ops/sec [157,349..163,515] ~ overlap (+1.7%)
simple object destructuring 137,429 ops/sec [136,154..139,773] → 137,001 ops/sec [135,971..137,402] ~ overlap (-0.3%) 158,343 ops/sec [157,542..160,083] → 170,545 ops/sec [167,970..172,784] 🟢 +7.7%
with defaults 155,274 ops/sec [155,002..155,458] → 151,373 ops/sec [150,954..151,920] 🔴 -2.5% 199,169 ops/sec [196,702..206,796] → 217,187 ops/sec [214,606..222,486] 🟢 +9.0%
with renaming 145,594 ops/sec [144,057..149,417] → 145,767 ops/sec [144,216..145,980] ~ overlap (+0.1%) 153,797 ops/sec [150,408..157,674] → 166,070 ops/sec [163,076..169,061] 🟢 +8.0%
nested object destructuring 75,888 ops/sec [74,563..76,980] → 73,721 ops/sec [73,367..78,005] ~ overlap (-2.9%) 82,772 ops/sec [79,116..84,139] → 85,184 ops/sec [83,916..87,956] ~ overlap (+2.9%)
rest properties 54,210 ops/sec [53,425..54,946] → 55,123 ops/sec [54,614..56,019] ~ overlap (+1.7%) 74,775 ops/sec [74,309..75,870] → 80,089 ops/sec [79,633..81,893] 🟢 +7.1%
object parameter 42,481 ops/sec [41,878..43,081] → 41,573 ops/sec [40,716..42,891] ~ overlap (-2.1%) 67,900 ops/sec [66,239..69,283] → 72,039 ops/sec [71,820..72,253] 🟢 +6.1%
array parameter 51,657 ops/sec [50,880..53,010] → 51,670 ops/sec [51,158..52,031] ~ overlap (+0.0%) 63,174 ops/sec [61,732..64,360] → 62,357 ops/sec [60,804..63,446] ~ overlap (-1.3%)
mixed destructuring in map 11,582 ops/sec [11,424..11,664] → 11,582 ops/sec [11,428..11,640] ~ overlap (+0.0%) 17,694 ops/sec [17,477..17,783] → 18,661 ops/sec [18,338..18,931] 🟢 +5.5%
forEach with array destructuring 25,419 ops/sec [25,081..25,683] → 26,008 ops/sec [25,827..26,437] 🟢 +2.3% 23,590 ops/sec [23,173..24,183] → 23,501 ops/sec [23,118..23,618] ~ overlap (-0.4%)
map with array destructuring 26,804 ops/sec [26,033..27,180] → 26,966 ops/sec [26,552..27,036] ~ overlap (+0.6%) 22,541 ops/sec [21,753..22,694] → 21,912 ops/sec [21,318..22,628] ~ overlap (-2.8%)
filter with array destructuring 26,660 ops/sec [26,268..27,008] → 27,012 ops/sec [26,785..27,163] ~ overlap (+1.3%) 23,605 ops/sec [23,195..23,908] → 23,654 ops/sec [23,105..24,753] ~ overlap (+0.2%)
reduce with array destructuring 30,090 ops/sec [29,138..30,378] → 29,736 ops/sec [29,666..29,766] ~ overlap (-1.2%) 25,246 ops/sec [24,918..25,609] → 24,331 ops/sec [24,111..24,895] 🔴 -3.6%
map with object destructuring 26,246 ops/sec [25,614..26,566] → 25,987 ops/sec [25,785..26,499] ~ overlap (-1.0%) 39,891 ops/sec [39,615..40,879] → 41,658 ops/sec [41,519..42,500] 🟢 +4.4%
map with nested destructuring 22,496 ops/sec [21,657..22,689] → 22,110 ops/sec [21,570..22,614] ~ overlap (-1.7%) 36,013 ops/sec [35,280..37,263] → 39,288 ops/sec [38,419..39,677] 🟢 +9.1%
map with rest in destructuring 16,547 ops/sec [16,331..16,818] → 16,643 ops/sec [16,422..16,983] ~ overlap (+0.6%) 12,568 ops/sec [12,481..12,663] → 12,272 ops/sec [11,955..12,816] ~ overlap (-2.4%)
map with defaults in destructuring 20,281 ops/sec [19,943..21,174] → 20,987 ops/sec [20,455..21,297] ~ overlap (+3.5%) 28,539 ops/sec [28,216..29,399] → 31,098 ops/sec [30,711..31,558] 🟢 +9.0%
fibonacci.js — Interp: 8 unch. · avg -0.2% · Bytecode: 🟢 5, 3 unch. · avg +5.1%
Benchmark Interpreted Δ Bytecode Δ
recursive fib(15) 101 ops/sec [98..104] → 102 ops/sec [99..104] ~ overlap (+0.6%) 540 ops/sec [535..555] → 612 ops/sec [601..620] 🟢 +13.4%
recursive fib(20) 9 ops/sec [9..9] → 9 ops/sec [9..9] ~ overlap (-0.4%) 49 ops/sec [49..49] → 52 ops/sec [51..54] 🟢 +6.2%
recursive fib(15) typed 104 ops/sec [101..105] → 104 ops/sec [102..106] ~ overlap (+0.1%) 560 ops/sec [547..567] → 581 ops/sec [573..632] 🟢 +3.8%
recursive fib(20) typed 9 ops/sec [9..9] → 9 ops/sec [9..9] ~ overlap (-0.1%) 50 ops/sec [50..51] → 55 ops/sec [53..58] 🟢 +9.4%
iterative fib(20) via reduce 4,613 ops/sec [4,491..4,721] → 4,688 ops/sec [4,641..4,808] ~ overlap (+1.6%) 9,919 ops/sec [9,883..9,923] → 10,121 ops/sec [9,926..10,445] 🟢 +2.0%
iterator fib(20) 3,658 ops/sec [3,596..3,700] → 3,637 ops/sec [3,581..3,673] ~ overlap (-0.6%) 6,359 ops/sec [6,259..6,713] → 6,747 ops/sec [6,553..6,972] ~ overlap (+6.1%)
iterator fib(20) via Iterator.from + take 4,984 ops/sec [4,878..4,991] → 4,883 ops/sec [4,842..4,957] ~ overlap (-2.0%) 7,700 ops/sec [7,522..7,890] → 7,674 ops/sec [7,611..7,683] ~ overlap (-0.3%)
iterator fib(20) last value via reduce 3,807 ops/sec [3,759..3,859] → 3,781 ops/sec [3,755..3,829] ~ overlap (-0.7%) 5,945 ops/sec [5,892..6,123] → 5,978 ops/sec [5,829..6,170] ~ overlap (+0.5%)
float16array.js — Interp: 🟢 7, 🔴 2, 23 unch. · avg +0.7% · Bytecode: 🟢 15, 🔴 5, 12 unch. · avg +0.1%
Benchmark Interpreted Δ Bytecode Δ
new Float16Array(0) 117,274 ops/sec [115,008..119,134] → 117,784 ops/sec [116,886..119,651] ~ overlap (+0.4%) 146,035 ops/sec [145,111..147,596] → 144,956 ops/sec [144,227..146,845] ~ overlap (-0.7%)
new Float16Array(100) 113,538 ops/sec [111,279..114,066] → 114,241 ops/sec [111,731..115,954] ~ overlap (+0.6%) 137,952 ops/sec [137,117..139,097] → 138,149 ops/sec [136,832..139,503] ~ overlap (+0.1%)
new Float16Array(1000) 95,514 ops/sec [94,563..95,913] → 97,378 ops/sec [95,247..98,618] ~ overlap (+2.0%) 114,318 ops/sec [113,070..117,147] → 112,459 ops/sec [111,023..113,479] ~ overlap (-1.6%)
Float16Array.from([...100]) 4,961 ops/sec [4,830..5,000] → 5,065 ops/sec [5,018..5,114] 🟢 +2.1% 5,164 ops/sec [5,091..5,224] → 5,314 ops/sec [5,238..5,401] 🟢 +2.9%
Float16Array.of(1.5, 2.5, 3.5, 4.5, 5.5) 127,257 ops/sec [126,534..127,591] → 128,608 ops/sec [126,007..129,640] ~ overlap (+1.1%) 107,980 ops/sec [105,721..111,257] → 113,024 ops/sec [111,822..113,696] 🟢 +4.7%
new Float16Array(float64Array) 80,017 ops/sec [77,907..81,758] → 82,517 ops/sec [80,582..82,945] ~ overlap (+3.1%) 89,976 ops/sec [89,051..90,641] → 97,318 ops/sec [96,831..97,975] 🟢 +8.2%
sequential write 100 elements 1,316 ops/sec [1,292..1,339] → 1,337 ops/sec [1,329..1,342] ~ overlap (+1.6%) 4,671 ops/sec [4,571..4,702] → 4,586 ops/sec [4,542..4,656] ~ overlap (-1.8%)
sequential read 100 elements 1,496 ops/sec [1,473..1,504] → 1,536 ops/sec [1,510..1,552] 🟢 +2.7% 6,306 ops/sec [6,253..6,436] → 6,151 ops/sec [5,887..6,350] ~ overlap (-2.5%)
write special values (NaN, Inf, -0) 63,837 ops/sec [62,195..64,885] → 62,973 ops/sec [61,980..63,230] ~ overlap (-1.4%) 127,528 ops/sec [125,117..129,452] → 137,656 ops/sec [135,720..140,142] 🟢 +7.9%
Float16Array write 1,373 ops/sec [1,361..1,384] → 1,358 ops/sec [1,348..1,359] 🔴 -1.1% 4,567 ops/sec [4,544..4,639] → 4,633 ops/sec [4,520..4,789] ~ overlap (+1.5%)
Float32Array write 1,323 ops/sec [1,313..1,357] → 1,381 ops/sec [1,367..1,385] 🟢 +4.4% 4,653 ops/sec [4,625..4,696] → 4,561 ops/sec [4,521..4,628] ~ overlap (-2.0%)
Float64Array write 1,346 ops/sec [1,342..1,365] → 1,345 ops/sec [1,339..1,370] ~ overlap (-0.1%) 4,695 ops/sec [4,643..4,775] → 4,632 ops/sec [4,589..4,662] ~ overlap (-1.3%)
Float16Array read 1,459 ops/sec [1,451..1,469] → 1,479 ops/sec [1,470..1,486] 🟢 +1.4% 6,018 ops/sec [5,910..6,066] → 5,588 ops/sec [5,458..5,622] 🔴 -7.1%
Float32Array read 1,491 ops/sec [1,441..1,501] → 1,489 ops/sec [1,479..1,494] ~ overlap (-0.2%) 6,306 ops/sec [6,242..6,399] → 6,384 ops/sec [6,275..6,491] ~ overlap (+1.2%)
Float64Array read 1,493 ops/sec [1,489..1,500] → 1,531 ops/sec [1,507..1,542] 🟢 +2.5% 6,324 ops/sec [6,250..6,453] → 6,372 ops/sec [6,323..6,417] ~ overlap (+0.8%)
fill(1.5) 21,687 ops/sec [21,400..21,911] → 21,593 ops/sec [20,787..21,720] ~ overlap (-0.4%) 23,107 ops/sec [22,642..23,814] → 23,583 ops/sec [23,366..23,745] ~ overlap (+2.1%)
slice() 86,308 ops/sec [86,045..86,485] → 87,176 ops/sec [86,320..87,957] ~ overlap (+1.0%) 90,875 ops/sec [89,498..91,088] → 97,214 ops/sec [96,397..99,273] 🟢 +7.0%
map(x => x * 2) 2,481 ops/sec [2,429..2,503] → 2,539 ops/sec [2,500..2,572] ~ overlap (+2.4%) 3,801 ops/sec [3,715..3,898] → 3,968 ops/sec [3,925..4,054] 🟢 +4.4%
filter(x => x > 25) 2,584 ops/sec [2,529..2,650] → 2,535 ops/sec [2,508..2,566] ~ overlap (-1.9%) 4,207 ops/sec [4,189..4,315] → 4,491 ops/sec [4,396..4,498] 🟢 +6.7%
reduce (sum) 2,509 ops/sec [2,481..2,646] → 2,544 ops/sec [2,533..2,565] ~ overlap (+1.4%) 3,594 ops/sec [3,510..3,748] → 3,712 ops/sec [3,643..3,790] ~ overlap (+3.3%)
sort() 20,889 ops/sec [20,816..20,911] → 20,878 ops/sec [20,654..20,903] ~ overlap (-0.1%) 23,802 ops/sec [23,127..24,025] → 17,922 ops/sec [17,864..18,147] 🔴 -24.7%
indexOf() 106,467 ops/sec [104,768..107,623] → 104,950 ops/sec [100,841..106,128] ~ overlap (-1.4%) 132,347 ops/sec [131,010..132,977] → 109,100 ops/sec [107,192..109,843] 🔴 -17.6%
reverse() 106,203 ops/sec [105,131..107,799] → 109,823 ops/sec [109,115..110,807] 🟢 +3.4% 119,220 ops/sec [118,213..120,204] → 131,576 ops/sec [130,020..132,006] 🟢 +10.4%
toReversed() 54,619 ops/sec [53,518..55,358] → 54,894 ops/sec [54,708..55,261] ~ overlap (+0.5%) 61,063 ops/sec [61,007..61,219] → 52,106 ops/sec [51,680..52,781] 🔴 -14.7%
toSorted() 819 ops/sec [804..824] → 831 ops/sec [824..836] ~ overlap (+1.4%) 917 ops/sec [904..931] → 690 ops/sec [686..695] 🔴 -24.7%
create view over existing buffer 131,254 ops/sec [130,476..131,495] → 133,324 ops/sec [131,675..134,866] 🟢 +1.6% 159,943 ops/sec [155,003..161,032] → 169,458 ops/sec [164,241..170,664] 🟢 +5.9%
subarray() 176,847 ops/sec [174,599..180,824] → 178,220 ops/sec [176,094..179,188] ~ overlap (+0.8%) 226,166 ops/sec [222,890..230,125] → 233,683 ops/sec [232,632..236,542] 🟢 +3.3%
set() from array 195,618 ops/sec [191,955..199,166] → 194,938 ops/sec [193,524..196,304] ~ overlap (-0.3%) 248,914 ops/sec [245,078..250,918] → 274,937 ops/sec [267,409..280,771] 🟢 +10.5%
for-of loop 2,154 ops/sec [2,137..2,186] → 2,174 ops/sec [2,116..2,195] ~ overlap (+0.9%) 9,050 ops/sec [8,986..9,147] → 9,214 ops/sec [9,165..9,268] 🟢 +1.8%
spread into array 8,822 ops/sec [8,346..8,882] → 8,830 ops/sec [8,400..9,036] ~ overlap (+0.1%) 34,928 ops/sec [33,772..36,196] → 37,142 ops/sec [36,685..37,924] 🟢 +6.3%
f16round(1.337) 254,827 ops/sec [254,061..255,861] → 244,491 ops/sec [241,449..248,522] 🔴 -4.1% 244,143 ops/sec [242,607..244,549] → 262,042 ops/sec [259,713..266,031] 🟢 +7.3%
f16round over 100 values 1,520 ops/sec [1,482..1,551] → 1,476 ops/sec [1,470..1,515] ~ overlap (-2.9%) 2,864 ops/sec [2,847..2,870] → 2,995 ops/sec [2,945..3,037] 🟢 +4.6%
for-of.js — Interp: 🟢 1, 6 unch. · avg +0.2% · Bytecode: 🟢 4, 3 unch. · avg +5.5%
Benchmark Interpreted Δ Bytecode Δ
for...of with 10-element array 19,067 ops/sec [18,923..19,208] → 19,314 ops/sec [19,188..19,461] ~ overlap (+1.3%) 116,020 ops/sec [114,744..117,238] → 122,959 ops/sec [119,212..125,883] 🟢 +6.0%
for...of with 100-element array 2,194 ops/sec [2,184..2,257] → 2,212 ops/sec [2,191..2,252] ~ overlap (+0.8%) 14,674 ops/sec [14,518..14,805] → 16,426 ops/sec [16,263..16,429] 🟢 +11.9%
for...of with string (10 chars) 13,964 ops/sec [13,715..14,039] → 13,985 ops/sec [13,841..14,382] ~ overlap (+0.1%) 33,004 ops/sec [32,505..34,236] → 35,931 ops/sec [34,874..36,431] 🟢 +8.9%
for...of with Set (10 elements) 19,823 ops/sec [19,728..19,945] → 20,031 ops/sec [19,965..20,084] 🟢 +1.0% 110,553 ops/sec [106,951..111,344] → 122,812 ops/sec [117,279..125,534] 🟢 +11.1%
for...of with Map entries (10 entries) 13,256 ops/sec [13,136..13,433] → 13,319 ops/sec [13,163..13,432] ~ overlap (+0.5%) 16,718 ops/sec [14,590..16,947] → 16,701 ops/sec [16,264..17,049] ~ overlap (-0.1%)
for...of with destructuring 16,564 ops/sec [16,338..16,723] → 16,626 ops/sec [16,522..16,682] ~ overlap (+0.4%) 21,527 ops/sec [21,332..21,913] → 21,679 ops/sec [21,046..22,704] ~ overlap (+0.7%)
for-await-of with sync array 18,730 ops/sec [18,422..19,030] → 18,262 ops/sec [18,068..18,677] ~ overlap (-2.5%) 17,859 ops/sec [17,665..17,959] → 17,831 ops/sec [17,029..18,364] ~ overlap (-0.2%)
generators.js — Interp: 4 unch. · avg +1.7% · Bytecode: 🟢 1, 🔴 1, 2 unch. · avg +0.5%
Benchmark Interpreted Δ Bytecode Δ
manual next over object generator 851 ops/sec [839..871] → 858 ops/sec [842..867] ~ overlap (+0.8%) 1,106 ops/sec [1,087..1,108] → 1,125 ops/sec [1,104..1,133] ~ overlap (+1.7%)
for...of over object generator 1,333 ops/sec [1,319..1,369] → 1,356 ops/sec [1,341..1,384] ~ overlap (+1.7%) 2,110 ops/sec [2,074..2,165] → 2,165 ops/sec [2,124..2,178] ~ overlap (+2.6%)
yield delegation 1,323 ops/sec [1,312..1,358] → 1,364 ops/sec [1,337..1,379] ~ overlap (+3.1%) 2,158 ops/sec [2,137..2,181] → 2,060 ops/sec [2,024..2,100] 🔴 -4.5%
class generator method 1,345 ops/sec [1,327..1,384] → 1,363 ops/sec [1,349..1,368] ~ overlap (+1.4%) 2,104 ops/sec [2,070..2,143] → 2,153 ops/sec [2,144..2,161] 🟢 +2.4%
iterators.js — Interp: 🟢 11, 🔴 1, 30 unch. · avg +1.1% · Bytecode: 🟢 35, 7 unch. · avg +6.2%
Benchmark Interpreted Δ Bytecode Δ
Iterator.from({next}).toArray() — 20 elements 4,522 ops/sec [4,413..4,595] → 4,464 ops/sec [4,357..4,536] ~ overlap (-1.3%) 6,674 ops/sec [6,604..6,807] → 7,300 ops/sec [7,205..7,456] 🟢 +9.4%
Iterator.from({next}).toArray() — 50 elements 1,902 ops/sec [1,874..1,917] → 1,908 ops/sec [1,888..1,933] ~ overlap (+0.4%) 3,040 ops/sec [2,974..3,056] → 3,211 ops/sec [3,176..3,276] 🟢 +5.6%
spread pre-wrapped iterator — 20 elements 4,456 ops/sec [4,406..4,533] → 4,518 ops/sec [4,382..4,589] ~ overlap (+1.4%) 6,886 ops/sec [6,817..6,947] → 7,397 ops/sec [7,236..7,539] 🟢 +7.4%
Iterator.from({next}).forEach — 50 elements 1,382 ops/sec [1,376..1,390] → 1,408 ops/sec [1,405..1,456] 🟢 +1.9% 2,272 ops/sec [2,232..2,312] → 2,461 ops/sec [2,420..2,496] 🟢 +8.3%
Iterator.from({next}).reduce — 50 elements 1,410 ops/sec [1,398..1,425] → 1,440 ops/sec [1,430..1,452] 🟢 +2.1% 2,202 ops/sec [2,175..2,224] → 2,388 ops/sec [2,338..2,536] 🟢 +8.5%
wrap array iterator 71,489 ops/sec [70,697..71,888] → 72,721 ops/sec [72,023..73,538] 🟢 +1.7% 76,966 ops/sec [75,430..77,407] → 84,392 ops/sec [80,702..85,133] 🟢 +9.6%
wrap plain {next()} object 3,100 ops/sec [3,070..3,175] → 3,109 ops/sec [3,072..3,120] ~ overlap (+0.3%) 4,851 ops/sec [4,792..4,920] → 5,120 ops/sec [5,092..5,150] 🟢 +5.6%
map + toArray (50 elements) 1,406 ops/sec [1,397..1,435] → 1,462 ops/sec [1,445..1,472] 🟢 +4.0% 2,280 ops/sec [2,266..2,297] → 2,361 ops/sec [2,297..2,427] ~ overlap (+3.5%)
filter + toArray (50 elements) 1,421 ops/sec [1,394..1,434] → 1,432 ops/sec [1,411..1,446] ~ overlap (+0.8%) 2,224 ops/sec [2,195..2,240] → 2,444 ops/sec [2,369..2,515] 🟢 +9.9%
take(10) + toArray (50 element source) 8,688 ops/sec [8,544..8,877] → 8,857 ops/sec [8,812..8,950] ~ overlap (+1.9%) 12,991 ops/sec [12,852..13,176] → 15,039 ops/sec [13,681..15,309] 🟢 +15.8%
drop(40) + toArray (50 element source) 1,927 ops/sec [1,919..1,946] → 1,981 ops/sec [1,968..2,004] 🟢 +2.8% 2,982 ops/sec [2,951..3,028] → 3,295 ops/sec [3,233..3,495] 🟢 +10.5%
chained map + filter + take (100 element source) 2,710 ops/sec [2,701..2,722] → 2,711 ops/sec [2,692..2,743] ~ overlap (+0.1%) 4,276 ops/sec [4,238..4,298] → 4,617 ops/sec [4,588..4,761] 🟢 +8.0%
some + every (50 elements) 802 ops/sec [799..805] → 819 ops/sec [812..826] 🟢 +2.2% 1,300 ops/sec [1,283..1,310] → 1,528 ops/sec [1,462..1,584] 🟢 +17.5%
find (50 elements) 1,789 ops/sec [1,770..1,805] → 1,798 ops/sec [1,779..1,821] ~ overlap (+0.5%) 2,842 ops/sec [2,825..2,846] → 2,964 ops/sec [2,919..3,001] 🟢 +4.3%
concat 2 arrays (10 + 10 elements) 67,916 ops/sec [66,937..69,070] → 69,536 ops/sec [68,881..70,111] ~ overlap (+2.4%) 74,698 ops/sec [73,733..75,514] → 79,543 ops/sec [78,398..81,210] 🟢 +6.5%
concat 5 arrays (10 elements each) 41,063 ops/sec [39,915..41,606] → 41,682 ops/sec [41,207..42,975] ~ overlap (+1.5%) 45,509 ops/sec [45,085..45,788] → 47,176 ops/sec [46,548..48,405] 🟢 +3.7%
concat 2 arrays (20 + 20 elements) 59,592 ops/sec [58,378..60,196] → 61,549 ops/sec [60,267..62,056] 🟢 +3.3% 64,778 ops/sec [63,506..65,118] → 69,718 ops/sec [69,438..70,174] 🟢 +7.6%
concat + filter + toArray (20 + 20 elements) 5,834 ops/sec [5,759..5,876] → 5,939 ops/sec [5,835..6,122] ~ overlap (+1.8%) 9,591 ops/sec [9,480..9,631] → 10,542 ops/sec [10,462..10,808] 🟢 +9.9%
concat + map + take (20 + 20 elements, take 10) 18,335 ops/sec [18,223..18,634] → 18,739 ops/sec [18,484..19,037] ~ overlap (+2.2%) 26,810 ops/sec [26,454..27,324] → 28,718 ops/sec [28,135..29,359] 🟢 +7.1%
concat Sets (15 + 15 elements) 67,925 ops/sec [66,949..69,319] → 68,068 ops/sec [67,642..70,390] ~ overlap (+0.2%) 70,971 ops/sec [70,447..71,184] → 77,143 ops/sec [76,013..77,700] 🟢 +8.7%
concat strings (13 + 13 characters) 49,050 ops/sec [48,313..49,870] → 48,525 ops/sec [48,125..49,726] ~ overlap (-1.1%) 47,245 ops/sec [46,772..47,904] → 51,121 ops/sec [50,667..51,205] 🟢 +8.2%
zip 2 arrays (10 + 10 elements) 28,033 ops/sec [27,386..28,463] → 28,232 ops/sec [27,698..28,351] ~ overlap (+0.7%) 28,967 ops/sec [28,631..29,052] → 30,560 ops/sec [29,877..31,043] 🟢 +5.5%
zip 3 arrays (10 elements each) 25,530 ops/sec [24,757..25,809] → 25,121 ops/sec [23,733..26,036] ~ overlap (-1.6%) 27,152 ops/sec [26,617..27,528] → 27,115 ops/sec [26,892..28,441] ~ overlap (-0.1%)
zip 2 arrays (20 + 20 elements) 18,839 ops/sec [18,462..19,109] → 18,447 ops/sec [17,906..18,683] ~ overlap (-2.1%) 19,382 ops/sec [19,333..19,549] → 19,764 ops/sec [19,290..20,139] ~ overlap (+2.0%)
zip 2 arrays (50 + 50 elements) 9,538 ops/sec [9,390..9,740] → 9,177 ops/sec [9,090..9,307] 🔴 -3.8% 9,782 ops/sec [9,614..9,853] → 10,182 ops/sec [9,876..10,277] 🟢 +4.1%
zip shortest mode (20 + 10 elements) 27,384 ops/sec [26,931..27,460] → 27,889 ops/sec [27,676..28,304] 🟢 +1.8% 28,555 ops/sec [28,280..29,625] → 29,518 ops/sec [26,299..30,347] ~ overlap (+3.4%)
zip longest mode (10 + 20 elements) 16,331 ops/sec [16,158..16,852] → 16,844 ops/sec [16,419..17,214] ~ overlap (+3.1%) 17,222 ops/sec [17,192..17,270] → 17,831 ops/sec [17,365..18,042] 🟢 +3.5%
zip strict mode (20 + 20 elements) 17,724 ops/sec [17,584..17,951] → 17,883 ops/sec [17,802..18,023] ~ overlap (+0.9%) 18,303 ops/sec [18,191..18,496] → 18,939 ops/sec [18,727..18,971] 🟢 +3.5%
zip + map + toArray (20 + 20 elements) 7,291 ops/sec [7,275..7,421] → 7,192 ops/sec [7,144..7,298] ~ overlap (-1.3%) 5,783 ops/sec [5,683..5,802] → 5,904 ops/sec [5,861..5,910] 🟢 +2.1%
zip + filter + toArray (20 + 20 elements) 6,954 ops/sec [6,930..7,031] → 7,222 ops/sec [7,129..7,272] 🟢 +3.9% 5,698 ops/sec [5,644..5,751] → 5,911 ops/sec [5,768..5,939] 🟢 +3.7%
zip Sets (15 + 15 elements) 23,317 ops/sec [23,160..23,838] → 23,502 ops/sec [23,191..24,390] ~ overlap (+0.8%) 23,501 ops/sec [23,381..23,633] → 25,109 ops/sec [24,548..25,513] 🟢 +6.8%
zipKeyed 2 keys (10 elements each) 28,609 ops/sec [28,433..29,146] → 28,724 ops/sec [28,316..29,039] ~ overlap (+0.4%) 29,117 ops/sec [28,802..29,540] → 29,679 ops/sec [29,165..30,829] ~ overlap (+1.9%)
zipKeyed 3 keys (20 elements each) 14,661 ops/sec [14,546..14,753] → 14,774 ops/sec [14,475..15,254] ~ overlap (+0.8%) 14,802 ops/sec [14,439..15,085] → 15,387 ops/sec [15,272..15,803] 🟢 +4.0%
zipKeyed longest mode (10 + 20 elements) 16,747 ops/sec [16,407..16,907] → 16,585 ops/sec [16,475..16,728] ~ overlap (-1.0%) 16,571 ops/sec [16,332..16,774] → 17,032 ops/sec [16,684..17,484] ~ overlap (+2.8%)
zipKeyed strict mode (20 + 20 elements) 17,241 ops/sec [16,998..17,521] → 17,497 ops/sec [17,071..17,805] ~ overlap (+1.5%) 17,565 ops/sec [17,448..17,640] → 18,364 ops/sec [18,049..18,466] 🟢 +4.5%
zipKeyed + filter + map (20 elements) 5,134 ops/sec [5,117..5,204] → 5,193 ops/sec [5,123..5,215] ~ overlap (+1.1%) 6,976 ops/sec [6,823..7,001] → 7,151 ops/sec [6,973..7,185] ~ overlap (+2.5%)
array.values().map().filter().toArray() 2,594 ops/sec [2,548..2,616] → 2,654 ops/sec [2,595..2,705] ~ overlap (+2.3%) 4,569 ops/sec [4,479..4,642] → 4,767 ops/sec [4,649..4,832] 🟢 +4.3%
array.values().take(5).toArray() 94,066 ops/sec [93,450..95,162] → 95,523 ops/sec [95,145..95,851] ~ overlap (+1.5%) 106,573 ops/sec [102,628..108,297] → 110,872 ops/sec [109,411..112,014] 🟢 +4.0%
array.values().drop(45).toArray() 75,925 ops/sec [75,241..76,576] → 77,491 ops/sec [76,796..77,624] 🟢 +2.1% 83,652 ops/sec [82,591..84,020] → 91,418 ops/sec [89,247..93,097] 🟢 +9.3%
map.entries() chained helpers 3,882 ops/sec [3,786..3,922] → 3,938 ops/sec [3,763..4,035] ~ overlap (+1.4%) 3,072 ops/sec [3,049..3,086] → 3,184 ops/sec [3,105..3,272] 🟢 +3.6%
set.values() chained helpers 5,989 ops/sec [5,850..6,099] → 6,118 ops/sec [5,974..6,174] ~ overlap (+2.2%) 9,837 ops/sec [9,725..9,914] → 10,664 ops/sec [10,546..11,149] 🟢 +8.4%
string iterator map + toArray 5,085 ops/sec [5,004..5,180] → 5,278 ops/sec [5,243..5,338] 🟢 +3.8% 5,818 ops/sec [5,743..5,970] → 6,198 ops/sec [6,129..6,352] 🟢 +6.5%
json.js — Interp: 🟢 7, 🔴 1, 12 unch. · avg +1.8% · Bytecode: 🟢 11, 🔴 1, 8 unch. · avg +4.0%
Benchmark Interpreted Δ Bytecode Δ
parse simple object 68,938 ops/sec [67,235..71,140] → 70,564 ops/sec [69,007..71,323] ~ overlap (+2.4%) 75,254 ops/sec [71,445..76,723] → 81,560 ops/sec [80,814..83,005] 🟢 +8.4%
parse nested object 46,359 ops/sec [44,625..47,051] → 47,717 ops/sec [47,640..47,824] 🟢 +2.9% 49,146 ops/sec [48,924..49,366] → 51,509 ops/sec [50,998..52,236] 🟢 +4.8%
parse array of objects 27,816 ops/sec [27,097..28,473] → 28,525 ops/sec [28,201..28,702] ~ overlap (+2.5%) 30,012 ops/sec [29,676..30,319] → 30,785 ops/sec [30,143..32,186] ~ overlap (+2.6%)
parse large flat object 29,281 ops/sec [28,424..31,827] → 30,960 ops/sec [30,451..32,490] ~ overlap (+5.7%) 32,202 ops/sec [31,961..32,600] → 34,752 ops/sec [34,288..35,315] 🟢 +7.9%
parse mixed types 34,473 ops/sec [34,221..35,741] → 35,372 ops/sec [34,821..36,669] ~ overlap (+2.6%) 38,927 ops/sec [38,583..39,439] → 39,660 ops/sec [39,277..40,194] ~ overlap (+1.9%)
stringify simple object 74,863 ops/sec [72,609..75,542] → 76,345 ops/sec [73,747..78,388] ~ overlap (+2.0%) 79,879 ops/sec [78,737..80,387] → 79,912 ops/sec [79,000..80,979] ~ overlap (+0.0%)
stringify nested object 43,057 ops/sec [42,377..43,846] → 44,689 ops/sec [43,154..45,770] ~ overlap (+3.8%) 43,219 ops/sec [41,014..44,216] → 44,811 ops/sec [44,517..45,454] 🟢 +3.7%
stringify array of objects 19,067 ops/sec [18,681..19,274] → 18,854 ops/sec [18,357..19,532] ~ overlap (-1.1%) 19,245 ops/sec [19,127..19,921] → 21,560 ops/sec [21,078..22,417] 🟢 +12.0%
stringify mixed types 30,217 ops/sec [29,867..30,386] → 29,344 ops/sec [28,965..31,972] ~ overlap (-2.9%) 28,731 ops/sec [28,267..29,005] → 30,718 ops/sec [30,511..31,901] 🟢 +6.9%
reviver doubles numbers 14,251 ops/sec [14,187..14,308] → 15,380 ops/sec [15,253..15,486] 🟢 +7.9% 18,941 ops/sec [18,641..19,952] → 19,355 ops/sec [19,021..19,381] ~ overlap (+2.2%)
reviver filters properties 13,375 ops/sec [13,160..13,459] → 13,984 ops/sec [13,829..14,100] 🟢 +4.6% 16,669 ops/sec [16,170..17,116] → 16,087 ops/sec [16,000..16,557] ~ overlap (-3.5%)
reviver on nested object 16,482 ops/sec [16,415..16,521] → 17,002 ops/sec [16,922..17,235] 🟢 +3.2% 20,679 ops/sec [20,628..20,784] → 20,751 ops/sec [20,556..21,114] ~ overlap (+0.3%)
reviver on array 9,002 ops/sec [8,623..9,062] → 9,108 ops/sec [9,061..9,429] ~ overlap (+1.2%) 12,352 ops/sec [12,112..12,419] → 11,848 ops/sec [11,766..11,956] 🔴 -4.1%
replacer function doubles numbers 16,947 ops/sec [16,871..17,024] → 16,634 ops/sec [16,535..16,704] 🔴 -1.8% 23,265 ops/sec [23,000..23,498] → 23,181 ops/sec [22,587..23,885] ~ overlap (-0.4%)
replacer function excludes properties 22,661 ops/sec [22,288..22,773] → 22,370 ops/sec [22,213..22,443] ~ overlap (-1.3%) 28,500 ops/sec [28,179..28,895] → 28,670 ops/sec [28,365..29,139] ~ overlap (+0.6%)
array replacer (allowlist) 50,781 ops/sec [47,214..51,345] → 48,026 ops/sec [47,463..48,694] ~ overlap (-5.4%) 46,119 ops/sec [45,570..47,981] → 48,557 ops/sec [48,217..49,694] 🟢 +5.3%
stringify with 2-space indent 37,225 ops/sec [36,493..37,501] → 38,249 ops/sec [37,676..39,257] 🟢 +2.8% 39,215 ops/sec [38,319..39,657] → 41,321 ops/sec [40,909..41,460] 🟢 +5.4%
stringify with tab indent 38,166 ops/sec [37,172..38,472] → 39,714 ops/sec [39,584..39,784] 🟢 +4.1% 37,820 ops/sec [37,735..37,952] → 41,290 ops/sec [40,884..42,129] 🟢 +9.2%
parse then stringify 22,774 ops/sec [22,687..22,869] → 23,911 ops/sec [23,392..24,105] 🟢 +5.0% 24,126 ops/sec [23,381..24,564] → 26,259 ops/sec [26,164..26,351] 🟢 +8.8%
stringify then parse 13,714 ops/sec [13,628..14,108] → 13,564 ops/sec [13,222..14,005] ~ overlap (-1.1%) 14,586 ops/sec [14,470..14,616] → 15,626 ops/sec [15,256..15,974] 🟢 +7.1%
jsx.jsx — Interp: 🔴 6, 15 unch. · avg -1.7% · Bytecode: 🟢 5, 16 unch. · avg +2.0%
Benchmark Interpreted Δ Bytecode Δ
simple element 92,317 ops/sec [90,940..94,367] → 89,448 ops/sec [89,003..89,845] 🔴 -3.1% 141,698 ops/sec [140,393..145,444] → 144,546 ops/sec [142,824..146,858] ~ overlap (+2.0%)
self-closing element 94,791 ops/sec [92,916..95,316] → 92,454 ops/sec [92,053..94,195] ~ overlap (-2.5%) 156,971 ops/sec [148,880..160,913] → 164,703 ops/sec [164,380..165,640] 🟢 +4.9%
element with string attribute 79,140 ops/sec [77,253..79,591] → 78,360 ops/sec [73,994..78,699] ~ overlap (-1.0%) 114,572 ops/sec [113,382..115,154] → 121,764 ops/sec [117,663..125,184] 🟢 +6.3%
element with multiple attributes 69,974 ops/sec [68,487..71,165] → 69,923 ops/sec [69,386..70,584] ~ overlap (-0.1%) 85,095 ops/sec [84,685..87,849] → 89,981 ops/sec [88,188..93,054] 🟢 +5.7%
element with expression attribute 74,163 ops/sec [72,734..75,416] → 72,549 ops/sec [71,368..73,110] ~ overlap (-2.2%) 121,988 ops/sec [120,189..125,031] → 119,387 ops/sec [117,420..126,355] ~ overlap (-2.1%)
text child 93,262 ops/sec [91,861..94,384] → 89,500 ops/sec [89,022..89,594] 🔴 -4.0% 141,745 ops/sec [134,931..147,913] → 145,058 ops/sec [143,285..154,481] ~ overlap (+2.3%)
expression child 89,402 ops/sec [89,211..90,146] → 85,707 ops/sec [84,817..86,547] 🔴 -4.1% 136,277 ops/sec [135,394..139,704] → 136,290 ops/sec [132,316..143,890] ~ overlap (+0.0%)
mixed text and expression 84,585 ops/sec [83,937..85,891] → 84,756 ops/sec [80,981..85,504] ~ overlap (+0.2%) 118,724 ops/sec [115,182..121,642] → 122,415 ops/sec [121,394..123,676] ~ overlap (+3.1%)
nested elements (3 levels) 35,545 ops/sec [35,150..35,660] → 34,868 ops/sec [34,323..35,137] 🔴 -1.9% 54,435 ops/sec [54,121..55,255] → 55,730 ops/sec [54,409..56,636] ~ overlap (+2.4%)
sibling children 26,885 ops/sec [26,391..27,048] → 26,343 ops/sec [25,591..26,730] ~ overlap (-2.0%) 39,443 ops/sec [39,083..41,380] → 40,501 ops/sec [39,620..41,199] ~ overlap (+2.7%)
component element 69,637 ops/sec [69,221..70,144] → 67,597 ops/sec [66,655..68,371] 🔴 -2.9% 108,138 ops/sec [105,871..110,829] → 107,538 ops/sec [105,178..109,984] ~ overlap (-0.6%)
component with children 42,833 ops/sec [41,863..43,252] → 42,449 ops/sec [42,306..42,884] ~ overlap (-0.9%) 63,954 ops/sec [63,493..64,625] → 63,557 ops/sec [63,199..65,653] ~ overlap (-0.6%)
dotted component 60,004 ops/sec [59,131..60,890] → 59,151 ops/sec [58,445..60,437] ~ overlap (-1.4%) 82,944 ops/sec [82,206..83,564] → 82,556 ops/sec [80,964..84,175] ~ overlap (-0.5%)
empty fragment 94,888 ops/sec [94,601..97,214] → 94,964 ops/sec [93,306..95,051] ~ overlap (+0.1%) 171,552 ops/sec [169,901..176,703] → 175,514 ops/sec [168,311..178,246] ~ overlap (+2.3%)
fragment with children 26,840 ops/sec [26,342..27,201] → 26,379 ops/sec [26,058..26,511] ~ overlap (-1.7%) 40,254 ops/sec [40,186..40,510] → 40,804 ops/sec [40,321..41,722] ~ overlap (+1.4%)
spread attributes 51,602 ops/sec [51,265..51,968] → 51,370 ops/sec [50,969..51,630] ~ overlap (-0.5%) 58,842 ops/sec [57,779..59,785] → 63,309 ops/sec [62,577..64,493] 🟢 +7.6%
spread with overrides 46,223 ops/sec [44,203..46,575] → 45,348 ops/sec [44,796..45,771] ~ overlap (-1.9%) 52,070 ops/sec [51,034..53,725] → 54,203 ops/sec [53,380..54,721] ~ overlap (+4.1%)
shorthand props 73,031 ops/sec [72,972..73,491] → 72,504 ops/sec [71,807..73,720] ~ overlap (-0.7%) 95,285 ops/sec [92,987..96,295] → 97,575 ops/sec [96,567..99,816] 🟢 +2.4%
nav bar structure 12,902 ops/sec [12,814..12,983] → 12,751 ops/sec [12,627..12,826] ~ overlap (-1.2%) 19,300 ops/sec [19,115..19,445] → 19,142 ops/sec [19,060..19,244] ~ overlap (-0.8%)
card component tree 15,345 ops/sec [15,119..15,496] → 15,134 ops/sec [15,009..15,257] ~ overlap (-1.4%) 20,739 ops/sec [20,613..20,762] → 20,713 ops/sec [20,511..20,826] ~ overlap (-0.1%)
10 list items via Array.from 6,794 ops/sec [6,755..6,811] → 6,583 ops/sec [6,424..6,620] 🔴 -3.1% 9,155 ops/sec [8,962..9,233] → 9,127 ops/sec [9,022..9,228] ~ overlap (-0.3%)
modules.js — Interp: 🔴 1, 8 unch. · avg -0.2% · Bytecode: 🟢 8, 1 unch. · avg +8.1%
Benchmark Interpreted Δ Bytecode Δ
call imported function 151,656 ops/sec [147,326..158,111] → 152,669 ops/sec [150,958..158,026] ~ overlap (+0.7%) 662,500 ops/sec [659,094..684,185] → 749,820 ops/sec [714,392..771,411] 🟢 +13.2%
call two imported functions 84,955 ops/sec [83,000..87,626] → 87,751 ops/sec [84,298..88,157] ~ overlap (+3.3%) 426,525 ops/sec [421,417..428,868] → 496,675 ops/sec [488,357..502,383] 🟢 +16.4%
read imported constant 498,842 ops/sec [479,695..523,808] → 507,198 ops/sec [503,722..513,041] ~ overlap (+1.7%) 1,625,027 ops/sec [1,601,931..1,640,557] → 1,767,616 ops/sec [1,758,860..1,781,752] 🟢 +8.8%
read imported string 488,440 ops/sec [480,104..509,094] → 490,809 ops/sec [481,583..503,082] ~ overlap (+0.5%) 1,600,360 ops/sec [1,591,566..1,669,704] → 1,760,974 ops/sec [1,758,758..1,763,255] 🟢 +10.0%
read JSON string property 505,416 ops/sec [504,530..517,276] → 490,087 ops/sec [467,539..504,174] 🔴 -3.0% 1,657,893 ops/sec [1,624,247..1,685,479] → 1,768,407 ops/sec [1,722,969..1,806,094] 🟢 +6.7%
read JSON number property 487,917 ops/sec [480,736..501,381] → 476,322 ops/sec [471,526..490,978] ~ overlap (-2.4%) 1,689,179 ops/sec [1,651,098..1,712,285] → 1,758,461 ops/sec [1,723,523..1,779,177] 🟢 +4.1%
read JSON boolean property 497,013 ops/sec [492,618..500,432] → 488,793 ops/sec [481,113..497,334] ~ overlap (-1.7%) 1,686,749 ops/sec [1,625,203..1,711,843] → 1,720,834 ops/sec [1,698,907..1,774,324] ~ overlap (+2.0%)
read JSON array property 490,517 ops/sec [487,089..507,781] → 483,659 ops/sec [473,493..497,573] ~ overlap (-1.4%) 1,615,750 ops/sec [1,600,214..1,632,048] → 1,728,870 ops/sec [1,685,185..1,767,141] 🟢 +7.0%
read multiple JSON properties 295,922 ops/sec [288,906..306,648] → 298,639 ops/sec [293,110..309,975] ~ overlap (+0.9%) 1,336,572 ops/sec [1,334,127..1,338,340] → 1,403,742 ops/sec [1,395,697..1,420,036] 🟢 +5.0%
numbers.js — Interp: 🟢 3, 8 unch. · avg +1.5% · Bytecode: 🟢 10, 1 unch. · avg +9.4%
Benchmark Interpreted Δ Bytecode Δ
integer arithmetic 160,118 ops/sec [158,825..161,481] → 163,464 ops/sec [161,559..163,835] 🟢 +2.1% 708,042 ops/sec [698,937..717,143] → 747,938 ops/sec [742,888..758,505] 🟢 +5.6%
floating point arithmetic 187,256 ops/sec [184,452..188,046] → 189,015 ops/sec [186,384..191,357] ~ overlap (+0.9%) 301,625 ops/sec [300,302..302,858] → 310,134 ops/sec [308,252..318,916] 🟢 +2.8%
number coercion 70,602 ops/sec [69,354..70,827] → 71,732 ops/sec [70,495..72,371] ~ overlap (+1.6%) 88,706 ops/sec [87,761..88,917] → 100,830 ops/sec [100,568..100,933] 🟢 +13.7%
toFixed 41,583 ops/sec [41,186..41,870] → 42,200 ops/sec [41,454..43,035] ~ overlap (+1.5%) 41,212 ops/sec [41,142..41,266] → 44,930 ops/sec [44,404..45,557] 🟢 +9.0%
toString 62,815 ops/sec [62,175..63,175] → 64,018 ops/sec [62,456..66,492] ~ overlap (+1.9%) 70,111 ops/sec [69,689..71,194] → 74,394 ops/sec [72,809..74,882] 🟢 +6.1%
valueOf 92,934 ops/sec [92,172..97,030] → 95,990 ops/sec [94,390..97,174] ~ overlap (+3.3%) 104,661 ops/sec [104,498..104,934] → 108,680 ops/sec [104,685..109,815] ~ overlap (+3.8%)
toPrecision 37,160 ops/sec [36,993..37,332] → 37,057 ops/sec [36,326..37,469] ~ overlap (-0.3%) 35,215 ops/sec [35,005..35,340] → 38,694 ops/sec [38,146..38,925] 🟢 +9.9%
Number.isNaN 112,394 ops/sec [110,785..114,291] → 114,510 ops/sec [113,444..118,057] ~ overlap (+1.9%) 113,297 ops/sec [109,881..113,634] → 128,108 ops/sec [125,766..132,377] 🟢 +13.1%
Number.isFinite 110,810 ops/sec [109,887..111,456] → 112,847 ops/sec [111,720..114,837] 🟢 +1.8% 97,696 ops/sec [96,508..98,744] → 113,695 ops/sec [108,753..114,468] 🟢 +16.4%
Number.isInteger 115,006 ops/sec [113,056..116,784] → 114,827 ops/sec [110,430..118,011] ~ overlap (-0.2%) 103,897 ops/sec [103,524..104,288] → 119,690 ops/sec [115,981..121,411] 🟢 +15.2%
Number.parseInt and parseFloat 89,316 ops/sec [88,090..89,645] → 91,410 ops/sec [89,781..91,941] 🟢 +2.3% 82,170 ops/sec [81,087..83,464] → 88,360 ops/sec [87,742..88,931] 🟢 +7.5%
objects.js — Interp: 🔴 4, 3 unch. · avg -2.7% · Bytecode: 🟢 3, 4 unch. · avg +4.1%
Benchmark Interpreted Δ Bytecode Δ
create simple object 205,901 ops/sec [203,635..206,350] → 198,242 ops/sec [195,065..200,488] 🔴 -3.7% 253,724 ops/sec [241,459..255,293] → 266,505 ops/sec [233,248..270,667] ~ overlap (+5.0%)
create nested object 110,172 ops/sec [107,343..111,534] → 107,739 ops/sec [105,499..109,194] ~ overlap (-2.2%) 109,294 ops/sec [108,258..110,057] → 113,482 ops/sec [112,700..114,531] 🟢 +3.8%
create 50 objects via Array.from 3,883 ops/sec [3,848..3,906] → 3,791 ops/sec [3,767..3,864] ~ overlap (-2.4%) 4,513 ops/sec [4,345..4,615] → 4,595 ops/sec [4,560..4,634] ~ overlap (+1.8%)
property read 188,057 ops/sec [186,937..188,860] → 188,945 ops/sec [187,834..189,803] ~ overlap (+0.5%) 289,162 ops/sec [285,340..290,682] → 315,692 ops/sec [309,694..323,696] 🟢 +9.2%
Object.keys 123,477 ops/sec [121,233..125,710] → 118,872 ops/sec [115,755..119,900] 🔴 -3.7% 139,516 ops/sec [138,058..140,698] → 145,470 ops/sec [143,093..147,596] 🟢 +4.3%
Object.entries 50,160 ops/sec [49,285..51,072] → 48,047 ops/sec [47,521..48,265] 🔴 -4.2% 53,598 ops/sec [52,235..55,314] → 54,021 ops/sec [52,605..54,807] ~ overlap (+0.8%)
spread operator 89,803 ops/sec [88,812..90,260] → 87,098 ops/sec [86,719..87,867] 🔴 -3.0% 98,097 ops/sec [95,720..101,396] → 101,874 ops/sec [100,649..103,930] ~ overlap (+3.9%)
promises.js — Interp: 🟢 3, 9 unch. · avg +2.0% · Bytecode: 🟢 8, 4 unch. · avg +4.8%
Benchmark Interpreted Δ Bytecode Δ
Promise.resolve(value) 196,263 ops/sec [189,162..197,374] → 199,540 ops/sec [194,987..202,928] ~ overlap (+1.7%) 213,065 ops/sec [210,487..215,943] → 234,204 ops/sec [231,692..235,395] 🟢 +9.9%
new Promise(resolve => resolve(value)) 76,570 ops/sec [75,647..78,446] → 78,178 ops/sec [77,759..78,798] ~ overlap (+2.1%) 105,363 ops/sec [104,633..106,718] → 108,190 ops/sec [106,133..110,422] ~ overlap (+2.7%)
Promise.reject(reason) 202,749 ops/sec [197,386..203,954] → 207,525 ops/sec [204,944..211,730] 🟢 +2.4% 220,310 ops/sec [214,062..224,622] → 232,701 ops/sec [229,561..239,607] 🟢 +5.6%
resolve + then (1 handler) 73,841 ops/sec [73,589..74,379] → 75,127 ops/sec [74,359..76,230] ~ overlap (+1.7%) 89,327 ops/sec [88,166..92,370] → 96,949 ops/sec [95,554..98,436] 🟢 +8.5%
resolve + then chain (3 deep) 30,115 ops/sec [29,791..30,264] → 30,889 ops/sec [30,622..30,977] 🟢 +2.6% 38,437 ops/sec [37,831..39,287] → 41,193 ops/sec [40,788..42,268] 🟢 +7.2%
resolve + then chain (10 deep) 9,938 ops/sec [9,751..9,973] → 10,516 ops/sec [9,897..10,800] ~ overlap (+5.8%) 12,829 ops/sec [12,434..13,062] → 13,779 ops/sec [13,717..13,915] 🟢 +7.4%
reject + catch + then 42,733 ops/sec [42,569..43,607] → 42,960 ops/sec [42,418..43,937] ~ overlap (+0.5%) 51,443 ops/sec [50,158..52,889] → 54,372 ops/sec [53,398..54,734] 🟢 +5.7%
resolve + finally + then 37,691 ops/sec [37,018..38,314] → 37,877 ops/sec [37,444..38,242] ~ overlap (+0.5%) 43,550 ops/sec [43,115..44,739] → 45,519 ops/sec [45,272..45,623] 🟢 +4.5%
Promise.all (5 resolved) 15,234 ops/sec [14,756..15,400] → 15,537 ops/sec [15,165..15,559] ~ overlap (+2.0%) 15,521 ops/sec [15,349..15,854] → 15,877 ops/sec [15,599..15,976] ~ overlap (+2.3%)
Promise.race (5 resolved) 16,305 ops/sec [16,006..16,536] → 16,224 ops/sec [16,062..16,464] ~ overlap (-0.5%) 16,259 ops/sec [16,179..16,338] → 16,828 ops/sec [16,421..16,974] 🟢 +3.5%
Promise.allSettled (5 mixed) 13,111 ops/sec [13,030..13,239] → 13,498 ops/sec [13,269..13,656] 🟢 +3.0% 13,604 ops/sec [13,292..13,730] → 13,602 ops/sec [13,040..13,825] ~ overlap (-0.0%)
Promise.any (5 mixed) 15,542 ops/sec [15,197..15,672] → 15,896 ops/sec [15,569..16,010] ~ overlap (+2.3%) 15,796 ops/sec [15,448..15,955] → 15,903 ops/sec [15,405..16,094] ~ overlap (+0.7%)
regexp.js — Interp: 🟢 2, 9 unch. · avg +1.0% · Bytecode: 🟢 10, 1 unch. · avg +7.2%
Benchmark Interpreted Δ Bytecode Δ
regex literal creation 69,061 ops/sec [68,369..70,289] → 69,086 ops/sec [67,767..71,250] ~ overlap (+0.0%) 64,398 ops/sec [63,219..65,199] → 69,226 ops/sec [67,092..70,026] 🟢 +7.5%
new RegExp(pattern, flags) 59,206 ops/sec [58,870..59,888] → 59,324 ops/sec [58,152..61,029] ~ overlap (+0.2%) 61,289 ops/sec [60,002..62,078] → 66,080 ops/sec [65,543..66,609] 🟢 +7.8%
RegExp(existingRegex) returns the same regex 248,108 ops/sec [244,214..249,448] → 247,265 ops/sec [244,018..248,328] ~ overlap (-0.3%) 406,778 ops/sec [383,216..414,418] → 439,426 ops/sec [430,048..465,997] 🟢 +8.0%
test() on a global regex 63,681 ops/sec [62,259..65,499] → 64,328 ops/sec [63,472..65,459] ~ overlap (+1.0%) 72,419 ops/sec [70,974..73,079] → 77,752 ops/sec [76,793..77,992] 🟢 +7.4%
exec() with capture groups 53,907 ops/sec [52,842..54,828] → 54,530 ops/sec [53,897..54,813] ~ overlap (+1.2%) 60,672 ops/sec [59,716..61,295] → 66,833 ops/sec [65,861..67,811] 🟢 +10.2%
toString() 184,556 ops/sec [182,886..185,632] → 187,970 ops/sec [186,099..189,655] 🟢 +1.8% 240,115 ops/sec [236,576..243,680] → 252,735 ops/sec [241,705..260,321] ~ overlap (+5.3%)
match() with global regex 19,145 ops/sec [18,788..19,540] → 19,371 ops/sec [19,234..19,551] ~ overlap (+1.2%) 19,325 ops/sec [19,042..19,525] → 20,011 ops/sec [19,943..20,057] 🟢 +3.5%
matchAll() with capture groups 9,853 ops/sec [9,817..9,882] → 9,770 ops/sec [9,741..9,911] ~ overlap (-0.8%) 11,740 ops/sec [11,672..11,811] → 12,780 ops/sec [12,524..12,927] 🟢 +8.9%
replace() with global regex 18,547 ops/sec [18,195..18,735] → 18,651 ops/sec [18,502..18,822] ~ overlap (+0.6%) 18,544 ops/sec [17,943..18,813] → 19,357 ops/sec [19,007..20,074] 🟢 +4.4%
search() with regex 37,743 ops/sec [37,272..38,445] → 38,562 ops/sec [38,317..39,026] ~ overlap (+2.2%) 36,453 ops/sec [36,033..36,773] → 39,581 ops/sec [39,520..39,722] 🟢 +8.6%
split() with regex separator 18,679 ops/sec [18,621..19,100] → 19,385 ops/sec [19,307..19,713] 🟢 +3.8% 18,850 ops/sec [18,666..19,267] → 20,251 ops/sec [19,983..20,473] 🟢 +7.4%
strings.js — Interp: 🔴 3, 16 unch. · avg -1.9% · Bytecode: 🟢 15, 4 unch. · avg +5.1%
Benchmark Interpreted Δ Bytecode Δ
string concatenation 153,048 ops/sec [150,421..155,979] → 146,885 ops/sec [146,114..148,628] 🔴 -4.0% 945,230 ops/sec [939,030..952,812] → 986,345 ops/sec [985,752..992,443] 🟢 +4.3%
template literal 292,985 ops/sec [281,284..301,012] → 281,935 ops/sec [278,773..283,530] ~ overlap (-3.8%) 637,721 ops/sec [622,954..643,829] → 666,678 ops/sec [653,811..687,534] 🟢 +4.5%
string repeat 168,351 ops/sec [163,043..174,599] → 168,430 ops/sec [161,133..169,781] ~ overlap (+0.0%) 210,664 ops/sec [210,127..211,224] → 210,088 ops/sec [207,645..210,936] ~ overlap (-0.3%)
split and join 28,976 ops/sec [27,951..29,671] → 28,594 ops/sec [27,795..28,790] ~ overlap (-1.3%) 29,024 ops/sec [28,672..29,407] → 31,483 ops/sec [30,760..31,985] 🟢 +8.5%
indexOf and includes 51,984 ops/sec [50,630..55,588] → 51,875 ops/sec [50,715..52,559] ~ overlap (-0.2%) 50,854 ops/sec [49,852..51,549] → 52,894 ops/sec [51,907..53,842] 🟢 +4.0%
toUpperCase and toLowerCase 84,545 ops/sec [83,074..85,965] → 82,783 ops/sec [81,889..83,186] ~ overlap (-2.1%) 93,842 ops/sec [93,136..96,805] → 92,524 ops/sec [91,086..93,287] ~ overlap (-1.4%)
slice and substring 52,101 ops/sec [50,785..53,628] → 52,134 ops/sec [50,724..52,881] ~ overlap (+0.1%) 54,915 ops/sec [54,674..55,882] → 56,910 ops/sec [56,621..58,644] 🟢 +3.6%
trim operations 79,737 ops/sec [78,489..80,411] → 73,400 ops/sec [72,724..75,678] 🔴 -7.9% 82,596 ops/sec [81,435..85,074] → 83,818 ops/sec [79,058..85,627] ~ overlap (+1.5%)
replace and replaceAll 80,725 ops/sec [79,475..81,162] → 79,335 ops/sec [78,368..80,281] ~ overlap (-1.7%) 74,356 ops/sec [71,492..76,475] → 79,987 ops/sec [79,173..80,747] 🟢 +7.6%
startsWith and endsWith 50,746 ops/sec [50,284..52,053] → 49,305 ops/sec [48,662..49,845] 🔴 -2.8% 44,919 ops/sec [44,396..45,921] → 48,018 ops/sec [46,933..49,484] 🟢 +6.9%
padStart and padEnd 75,351 ops/sec [73,082..76,046] → 73,881 ops/sec [72,765..74,495] ~ overlap (-2.0%) 74,478 ops/sec [74,206..75,060] → 77,682 ops/sec [76,009..77,997] 🟢 +4.3%
identity tag, no substitutions 166,029 ops/sec [162,575..169,927] → 163,413 ops/sec [162,835..164,491] ~ overlap (-1.6%) 554,083 ops/sec [534,770..565,987] → 612,676 ops/sec [605,825..617,015] 🟢 +10.6%
tag with 1 substitution 35,531 ops/sec [34,894..36,379] → 35,010 ops/sec [33,923..35,646] ~ overlap (-1.5%) 54,316 ops/sec [52,737..54,409] → 55,060 ops/sec [54,404..55,635] ~ overlap (+1.4%)
tag with 3 substitutions 19,209 ops/sec [18,656..19,434] → 18,575 ops/sec [18,257..18,750] ~ overlap (-3.3%) 30,243 ops/sec [29,728..30,621] → 32,079 ops/sec [31,795..33,013] 🟢 +6.1%
tag with 6 substitutions 11,306 ops/sec [10,985..11,459] → 10,984 ops/sec [10,918..11,019] ~ overlap (-2.9%) 17,774 ops/sec [17,459..18,424] → 19,187 ops/sec [18,983..19,382] 🟢 +7.9%
String.raw, no substitutions 226,495 ops/sec [223,294..231,973] → 228,733 ops/sec [226,122..231,418] ~ overlap (+1.0%) 229,410 ops/sec [224,573..231,969] → 247,259 ops/sec [244,420..252,777] 🟢 +7.8%
String.raw, 2 substitutions 163,113 ops/sec [158,788..167,706] → 162,500 ops/sec [159,058..165,941] ~ overlap (-0.4%) 148,265 ops/sec [147,476..148,987] → 161,850 ops/sec [160,126..164,173] 🟢 +9.2%
tag accessing .raw array 67,125 ops/sec [66,180..68,047] → 66,643 ops/sec [65,560..67,313] ~ overlap (-0.7%) 91,012 ops/sec [89,396..91,704] → 94,745 ops/sec [93,659..97,431] 🟢 +4.1%
method as tag (this binding) 25,616 ops/sec [25,506..26,255] → 25,310 ops/sec [25,184..25,681] ~ overlap (-1.2%) 40,028 ops/sec [39,673..40,148] → 42,529 ops/sec [42,154..42,711] 🟢 +6.2%
tsv.js — Interp: 🟢 3, 6 unch. · avg +2.7% · Bytecode: 🟢 7, 2 unch. · avg +10.1%
Benchmark Interpreted Δ Bytecode Δ
parse simple 3-column TSV 45,988 ops/sec [45,463..46,919] → 46,227 ops/sec [45,668..46,508] ~ overlap (+0.5%) 50,645 ops/sec [49,899..50,840] → 51,766 ops/sec [50,940..52,071] 🟢 +2.2%
parse 10-row TSV 12,637 ops/sec [12,496..12,728] → 12,747 ops/sec [12,623..13,129] ~ overlap (+0.9%) 13,224 ops/sec [12,950..13,283] → 13,976 ops/sec [13,931..14,382] 🟢 +5.7%
parse 100-row TSV 1,932 ops/sec [1,858..2,042] → 2,003 ops/sec [1,999..2,034] ~ overlap (+3.7%) 2,051 ops/sec [2,011..2,130] → 2,181 ops/sec [2,129..2,216] ~ overlap (+6.3%)
parse TSV with backslash-escaped fields 9,117 ops/sec [9,081..9,141] → 9,357 ops/sec [9,258..9,492] 🟢 +2.6% 9,770 ops/sec [9,727..9,876] → 10,092 ops/sec [9,942..10,234] 🟢 +3.3%
parse without headers (array of arrays) 5,434 ops/sec [5,271..5,490] → 5,830 ops/sec [5,795..5,839] 🟢 +7.3% 6,031 ops/sec [5,969..6,080] → 6,089 ops/sec [6,033..6,185] ~ overlap (+1.0%)
stringify array of objects 39,447 ops/sec [38,993..39,820] → 39,967 ops/sec [39,354..40,351] ~ overlap (+1.3%) 40,349 ops/sec [38,801..40,498] → 46,110 ops/sec [46,002..46,408] 🟢 +14.3%
stringify array of arrays 11,253 ops/sec [11,095..11,563] → 11,529 ops/sec [11,211..11,575] ~ overlap (+2.5%) 10,207 ops/sec [10,104..10,301] → 13,138 ops/sec [13,048..13,161] 🟢 +28.7%
stringify with values needing escaping 30,211 ops/sec [29,763..30,371] → 30,712 ops/sec [30,284..30,787] ~ overlap (+1.7%) 30,516 ops/sec [30,215..31,081] → 35,152 ops/sec [35,068..35,203] 🟢 +15.2%
parse then stringify 6,979 ops/sec [6,886..7,037] → 7,250 ops/sec [7,214..7,377] 🟢 +3.9% 6,961 ops/sec [6,938..7,280] → 7,974 ops/sec [7,775..8,130] 🟢 +14.6%
typed-arrays.js — Interp: 🟢 6, 🔴 5, 11 unch. · avg -3.3% · Bytecode: 🟢 6, 🔴 9, 7 unch. · avg +1.8%
Benchmark Interpreted Δ Bytecode Δ
new Int32Array(0) 116,421 ops/sec [114,229..118,796] → 119,165 ops/sec [117,457..119,975] ~ overlap (+2.4%) 139,668 ops/sec [138,492..142,823] → 146,417 ops/sec [145,629..147,020] 🟢 +4.8%
new Int32Array(100) 110,291 ops/sec [109,021..113,184] → 112,793 ops/sec [111,058..114,110] ~ overlap (+2.3%) 133,856 ops/sec [130,175..136,197] → 134,195 ops/sec [132,073..135,841] ~ overlap (+0.3%)
new Int32Array(1000) 86,245 ops/sec [85,427..86,637] → 85,983 ops/sec [85,721..87,583] ~ overlap (-0.3%) 101,236 ops/sec [99,522..101,544] → 93,123 ops/sec [90,984..94,178] 🔴 -8.0%
new Float64Array(100) 111,858 ops/sec [110,959..113,110] → 112,648 ops/sec [111,524..113,189] ~ overlap (+0.7%) 128,243 ops/sec [127,591..129,826] → 128,182 ops/sec [124,691..128,926] ~ overlap (-0.0%)
Int32Array.from([...]) 5,004 ops/sec [4,921..5,088] → 5,061 ops/sec [4,990..5,109] ~ overlap (+1.1%) 5,177 ops/sec [5,062..5,225] → 5,096 ops/sec [4,901..5,224] ~ overlap (-1.6%)
Int32Array.of(1, 2, 3, 4, 5) 132,817 ops/sec [128,471..134,070] → 132,568 ops/sec [131,544..133,937] ~ overlap (-0.2%) 149,262 ops/sec [148,430..150,648] → 156,573 ops/sec [154,881..158,745] 🟢 +4.9%
sequential write 100 elements 1,502 ops/sec [1,499..1,506] → 1,528 ops/sec [1,489..1,533] ~ overlap (+1.7%) 6,804 ops/sec [6,678..6,856] → 6,751 ops/sec [6,650..6,809] ~ overlap (-0.8%)
sequential read 100 elements 1,620 ops/sec [1,613..1,628] → 1,578 ops/sec [1,563..1,588] 🔴 -2.6% 6,736 ops/sec [6,703..6,773] → 6,618 ops/sec [6,564..6,726] ~ overlap (-1.7%)
Float64Array write 100 elements 2,151 ops/sec [1,350..2,192] → 1,404 ops/sec [1,382..1,415] ~ overlap (-34.7%) 4,591 ops/sec [4,557..4,624] → 4,541 ops/sec [4,493..4,548] 🔴 -1.1%
fill(42) 42,818 ops/sec [42,541..43,069] → 25,150 ops/sec [24,301..25,373] 🔴 -41.3% 28,872 ops/sec [27,309..29,573] → 26,821 ops/sec [26,635..26,911] 🔴 -7.1%
slice() 107,821 ops/sec [105,669..109,894] → 109,213 ops/sec [108,252..110,510] ~ overlap (+1.3%) 204,022 ops/sec [189,580..206,221] → 132,472 ops/sec [132,291..133,593] 🔴 -35.1%
map(x => x * 2) 2,573 ops/sec [2,558..2,583] → 2,610 ops/sec [2,598..2,643] 🟢 +1.4% 7,693 ops/sec [7,687..7,709] → 4,355 ops/sec [4,346..4,374] 🔴 -43.4%
filter(x => x > 50) 2,694 ops/sec [2,619..2,705] → 2,725 ops/sec [2,685..2,735] ~ overlap (+1.1%) 8,468 ops/sec [8,335..8,537] → 4,790 ops/sec [4,758..4,801] 🔴 -43.4%
reduce (sum) 2,650 ops/sec [2,628..2,687] → 2,744 ops/sec [2,726..2,756] 🟢 +3.5% 7,180 ops/sec [7,033..7,243] → 4,145 ops/sec [4,118..4,174] 🔴 -42.3%
sort() 99,642 ops/sec [99,307..100,357] → 102,744 ops/sec [102,372..103,039] 🟢 +3.1% 193,826 ops/sec [193,034..194,239] → 122,497 ops/sec [122,363..123,029] 🔴 -36.8%
indexOf() 192,355 ops/sec [191,624..193,034] → 194,804 ops/sec [194,063..195,221] 🟢 +1.3% 412,271 ops/sec [410,601..415,005] → 363,086 ops/sec [361,024..365,126] 🔴 -11.9%
reverse() 152,699 ops/sec [151,607..153,826] → 160,066 ops/sec [158,678..160,393] 🟢 +4.8% 321,979 ops/sec [173,205..325,221] → 287,299 ops/sec [286,202..288,072] ~ overlap (-10.8%)
create view over existing buffer 135,969 ops/sec [133,269..148,100] → 215,735 ops/sec [214,575..216,286] 🟢 +58.7% 162,420 ops/sec [158,955..164,295] → 274,999 ops/sec [272,409..277,148] 🟢 +69.3%
subarray() 287,529 ops/sec [284,453..290,744] → 280,419 ops/sec [278,612..283,674] 🔴 -2.5% 212,982 ops/sec [212,607..217,597] → 356,044 ops/sec [353,626..361,563] 🟢 +67.2%
set() from array 343,605 ops/sec [335,325..347,519] → 347,692 ops/sec [343,845..348,555] ~ overlap (+1.2%) 263,368 ops/sec [260,804..264,855] → 477,871 ops/sec [354,462..480,829] 🟢 +81.4%
for-of loop 3,641 ops/sec [3,630..3,643] → 2,232 ops/sec [2,216..3,611] 🔴 -38.7% 10,634 ops/sec [10,595..10,651] → 17,381 ops/sec [16,995..17,683] 🟢 +63.4%
spread into array 14,450 ops/sec [14,259..14,565] → 9,089 ops/sec [9,039..9,162] 🔴 -37.1% 63,363 ops/sec [36,852..64,477] → 58,869 ops/sec [58,491..59,150] ~ overlap (-7.1%)
uint8array-encoding.js — Interp: 🟢 9, 🔴 7, 2 unch. · avg -7.9% · Bytecode: 🟢 13, 🔴 3, 2 unch. · avg +13.3%
Benchmark Interpreted Δ Bytecode Δ
short (5 bytes) 255,208 ops/sec [248,200..260,244] → 266,166 ops/sec [262,086..271,458] 🟢 +4.3% 359,947 ops/sec [356,903..368,811] → 398,988 ops/sec [396,423..434,350] 🟢 +10.8%
medium (450 bytes) 140,855 ops/sec [140,548..142,206] → 147,137 ops/sec [145,461..148,414] 🟢 +4.5% 172,028 ops/sec [170,660..173,805] → 192,200 ops/sec [188,886..197,165] 🟢 +11.7%
large (4096 bytes) 31,766 ops/sec [30,974..31,908] → 31,704 ops/sec [30,633..32,740] ~ overlap (-0.2%) 33,133 ops/sec [32,657..33,473] → 34,903 ops/sec [33,692..37,630] 🟢 +5.3%
base64url alphabet 102,524 ops/sec [102,051..102,850] → 159,600 ops/sec [105,808..165,449] 🟢 +55.7% 107,504 ops/sec [107,343..109,443] → 118,689 ops/sec [118,166..125,339] 🟢 +10.4%
omitPadding 154,895 ops/sec [153,466..155,854] → 159,483 ops/sec [158,526..159,654] 🟢 +3.0% 186,598 ops/sec [180,672..190,787] → 194,498 ops/sec [192,372..201,784] 🟢 +4.2%
short (8 chars) 139,957 ops/sec [137,921..140,688] → 144,904 ops/sec [143,741..146,286] 🟢 +3.5% 155,145 ops/sec [152,827..156,943] → 166,803 ops/sec [164,453..168,945] 🟢 +7.5%
medium (600 chars) 69,697 ops/sec [69,126..70,239] → 69,437 ops/sec [68,657..69,577] ~ overlap (-0.4%) 71,239 ops/sec [70,747..71,744] → 75,509 ops/sec [75,023..75,822] 🟢 +6.0%
large (5464 chars) 13,887 ops/sec [13,832..14,071] → 13,389 ops/sec [13,206..13,814] 🔴 -3.6% 13,679 ops/sec [13,597..13,762] → 14,172 ops/sec [13,818..14,426] 🟢 +3.6%
short (5 bytes) 262,143 ops/sec [261,386..275,233] → 287,557 ops/sec [287,039..287,946] 🟢 +9.7% 429,560 ops/sec [427,174..429,605] → 823,120 ops/sec [816,302..830,350] 🟢 +91.6%
medium (450 bytes) 122,922 ops/sec [121,335..123,596] → 131,653 ops/sec [131,144..133,175] 🟢 +7.1% 165,194 ops/sec [160,633..165,712] → 254,183 ops/sec [253,587..254,994] 🟢 +53.9%
large (4096 bytes) 22,826 ops/sec [22,646..22,968] → 24,164 ops/sec [23,480..24,492] 🟢 +5.9% 26,939 ops/sec [26,668..27,268] → 38,284 ops/sec [36,951..38,482] 🟢 +42.1%
short (10 chars) 243,972 ops/sec [234,015..245,743] → 155,621 ops/sec [153,894..159,155] 🔴 -36.2% 174,892 ops/sec [174,068..294,214] → 295,576 ops/sec [294,521..296,997] 🟢 +69.0%
medium (900 chars) 171,769 ops/sec [171,296..172,561] → 102,258 ops/sec [101,470..102,343] 🔴 -40.5% 116,698 ops/sec [115,890..117,367] → 112,489 ops/sec [109,917..190,071] ~ overlap (-3.6%)
large (8192 chars) 49,364 ops/sec [48,254..49,517] → 24,857 ops/sec [23,650..25,583] 🔴 -49.6% 30,787 ops/sec [30,490..31,470] → 25,780 ops/sec [25,444..26,371] 🔴 -16.3%
setFromBase64 (450 bytes) 112,049 ops/sec [110,928..112,357] → 67,601 ops/sec [66,694..68,029] 🔴 -39.7% 75,952 ops/sec [75,711..76,282] → 78,088 ops/sec [77,611..78,309] 🟢 +2.8%
setFromHex (450 bytes) 159,195 ops/sec [158,408..160,405] → 96,471 ops/sec [94,861..97,845] 🔴 -39.4% 111,184 ops/sec [106,995..194,555] → 111,560 ops/sec [107,595..113,603] ~ overlap (+0.3%)
toBase64 → fromBase64 (450 bytes) 82,589 ops/sec [82,067..82,888] → 53,483 ops/sec [53,008..53,672] 🔴 -35.2% 90,166 ops/sec [89,854..90,603] → 56,740 ops/sec [56,614..56,997] 🔴 -37.1%
toHex → fromHex (450 bytes) 105,365 ops/sec [105,045..105,629] → 115,623 ops/sec [113,789..115,880] 🟢 +9.7% 123,222 ops/sec [122,590..123,720] → 93,866 ops/sec [73,036..118,932] 🔴 -23.8%
weak-collections.js — Interp: 🟢 6, 🔴 2, 7 unch. · avg +24.6% · Bytecode: 🟢 9, 🔴 4, 2 unch. · avg -8.4%
Benchmark Interpreted Δ Bytecode Δ
constructor from 50 entries 11,936 ops/sec [11,417..19,132] → 18,303 ops/sec [12,430..20,310] ~ overlap (+53.3%) 12,224 ops/sec [12,008..12,382] → 13,079 ops/sec [12,886..13,497] 🟢 +7.0%
set 50 object keys 7,349 ops/sec [7,320..7,424] → 7,221 ops/sec [7,170..7,296] 🔴 -1.7% 5,982 ops/sec [5,934..6,102] → 6,489 ops/sec [6,430..6,558] 🟢 +8.5%
get lookups (50 entries) 95,128 ops/sec [94,772..95,347] → 94,758 ops/sec [93,296..95,241] ~ overlap (-0.4%) 90,614 ops/sec [89,118..91,577] → 103,460 ops/sec [100,035..104,242] 🟢 +14.2%
has checks (50 entries) 125,403 ops/sec [124,497..126,846] → 120,948 ops/sec [120,017..122,200] 🔴 -3.6% 117,763 ops/sec [114,831..119,773] → 126,374 ops/sec [125,690..127,431] 🟢 +7.3%
delete entries 4,140 ops/sec [4,123..4,173] → 6,707 ops/sec [6,664..6,750] 🟢 +62.0% 5,917 ops/sec [5,894..5,941] → 6,281 ops/sec [6,217..6,308] 🟢 +6.2%
non-registered symbol keys 16,308 ops/sec [10,040..16,443] → 16,295 ops/sec [16,230..16,465] ~ overlap (-0.1%) 14,081 ops/sec [13,308..14,108] → 15,254 ops/sec [14,987..15,390] 🟢 +8.3%
getOrInsert 6,657 ops/sec [6,597..6,749] → 6,667 ops/sec [6,559..6,769] ~ overlap (+0.2%) 5,268 ops/sec [5,240..5,591] → 5,675 ops/sec [5,607..5,730] 🟢 +7.7%
getOrInsertComputed 2,063 ops/sec [2,039..3,283] → 3,245 ops/sec [3,206..3,264] ~ overlap (+57.3%) 2,808 ops/sec [2,776..2,831] → 2,919 ops/sec [2,842..2,922] 🟢 +3.9%
forced gc live-key retention 4,302 ops/sec [4,240..4,354] → 4,258 ops/sec [4,221..6,999] ~ overlap (-1.0%) 5,460 ops/sec [5,411..5,496] → 5,697 ops/sec [5,545..5,751] 🟢 +4.3%
constructor from 50 values 15,411 ops/sec [14,878..15,555] → 16,626 ops/sec [16,509..16,690] 🟢 +7.9% 29,910 ops/sec [28,922..30,153] → 18,587 ops/sec [18,034..18,982] 🔴 -37.9%
add 50 object values 4,826 ops/sec [4,746..4,856] → 4,733 ops/sec [4,709..4,783] ~ overlap (-1.9%) 11,940 ops/sec [11,852..11,982] → 7,132 ops/sec [7,065..7,271] 🔴 -40.3%
has checks (50 values) 77,751 ops/sec [77,361..79,310] → 124,193 ops/sec [104,410..125,028] 🟢 +59.7% 205,621 ops/sec [118,909..209,895] → 127,232 ops/sec [120,240..128,528] ~ overlap (-38.1%)
delete values 12,273 ops/sec [12,067..12,391] → 20,965 ops/sec [20,262..21,186] 🟢 +70.8% 25,532 ops/sec [24,662..25,810] → 15,694 ops/sec [15,562..15,948] 🔴 -38.5%
non-registered symbol values 10,501 ops/sec [10,376..10,776] → 16,987 ops/sec [16,878..17,114] 🟢 +61.8% 26,437 ops/sec [25,604..26,666] → 15,958 ops/sec [15,790..16,150] 🔴 -39.6%
forced gc pruning smoke 8,207 ops/sec [6,126..8,237] → 8,616 ops/sec [8,592..8,652] 🟢 +5.0% 11,581 ops/sec [11,471..11,634] → 11,744 ops/sec [7,102..11,952] ~ overlap (+1.4%)

Deterministic profile diff

Deterministic profile diff: no significant changes.

Measured on ubuntu-latest x64. Benchmark ranges compare cached main-branch min/max ops/sec with the PR run; overlapping ranges are treated as unchanged noise. Percentage deltas are secondary context.

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented May 8, 2026

test262 Conformance

Category Run Passed Δ Pass Failed Pass-rate Δ Rate
built-ins 23,448 14,338 +1 9,109 61.1% ±0pp
harness 116 71 ±0 45 61.2% ±0pp
intl402 3,324 167 ±0 3,157 5.0% ±0pp
language 23,635 12,566 ±0 11,069 53.2% ±0pp
staging 1,483 469 ±0 1,012 31.6% ±0pp
total 52,006 27,611 +1 24,392 53.1% ±0pp

Areas closest to 100%

Area Pass rate Δ vs main Passing
built-ins/WeakSet 98.8% ±0pp 84 / 85
built-ins/WeakMap 98.6% ±0pp 139 / 141
language/asi 97.1% ±0pp 99 / 102
Per-test deltas (+1 / -0)

Newly passing (1):

  • built-ins/Number/prototype/toExponential/undefined-fractiondigits.js

Steady-state failures are non-blocking; regressions vs the cached main baseline (lower total pass count, or any PASS → non-PASS transition) fail the conformance gate. Measured on ubuntu-latest x64, bytecode mode. Areas grouped by the first two test262 path components; minimum 25 attempted tests, areas already at 100% excluded. Δ vs main compares against the most recent cached main baseline.

frostney and others added 2 commits May 8, 2026 10:15
Collapse toml-test-bump-pin.ts and yaml-test-bump-pin.ts into a single
suite-bump-pin.ts that accepts the target file as its first argument.
Rename ValidateInput to PrepareInput since it both strips the UTF-8 BOM
(mutating FIndex) and validates control characters.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
@frostney frostney marked this pull request as ready for review May 8, 2026 09:23
@coderabbitai coderabbitai Bot added spec compliance Mismatch against official JavaScript/TypeScript specification internal Refactoring, CI, tooling, cleanup labels May 8, 2026
@frostney frostney merged commit 0b171ea into main May 8, 2026
61 checks passed
@frostney frostney deleted the t3code/890fa929 branch May 8, 2026 10:05
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

internal Refactoring, CI, tooling, cleanup spec compliance Mismatch against official JavaScript/TypeScript specification

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant