Skip to content

fix(compiler): evaluate const increment RHS and recheck global for-limits - #1220

Open
frostney wants to merge 1 commit into
perf/w3-unmanaged-contextfrom
perf/w1-review-fixes
Open

fix(compiler): evaluate const increment RHS and recheck global for-limits#1220
frostney wants to merge 1 commit into
perf/w3-unmanaged-contextfrom
perf/w1-review-fixes

Conversation

@frostney

@frostney frostney commented Aug 27, 2026 •
edited
Loading

Copy link
Copy Markdown
Owner

Summary

  • Review-fix layer for #1215: const self-increment uses the generic assignment path so the RHS is evaluated before TDZ / const-assignment errors; counted-for no longer snapshots a global-backed limit register.
  • Top of stack #1215 ← #1216 ← #1217 ← #1219 ← #1220.
  • Also corrects the counted-for opcode wording in .agent/HANDOFF.md (OP_ADD_INT vs OP_SUB_INT) and adds a Use-when clause for the optimize-runtime skill.
  • Non-goals: nested write-IC helper extraction in the dispatch loop (previously measured FPC register-pressure failure); OP_SET_LOCAL in the hand-assembled GET_LOCAL_PROP_CONST VM test (GetLocalRegister already falls back to registers).

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

Local gates on 604f0ad7: ./format.pas --check; ./build.pas testrunner; ./build/GocciaTestRunner tests and --mode=bytecode (1615 files, 12818 tests, 0 failed each); ./build/Goccia.Compiler.Test (59/59).

@frostney @cursoragent
fix(compiler): evaluate const increment RHS and recheck global for-li…
604f0ad 
…mits

Co-authored-by: Cursor <cursoragent@cursor.com>
@vercel

vercel Bot commented Aug 27, 2026 •
edited
Loading

Copy link
Copy Markdown

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 Aug 27, 2026 1:32am

Request Review

@coderabbitai

coderabbitai Bot commented Aug 27, 2026 •
edited
Loading

Copy link
Copy Markdown
Contributor

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 Plus

Run ID: 48813f78-1ee4-42c8-bf56-7f1d1c862f6b

📥 Commits

Reviewing files that changed from the base of the PR and between 8377707 and 604f0ad.

📒 Files selected for processing (7)
  • .agent/HANDOFF.md
  • AGENTS.md
  • source/units/Goccia.Compiler.Expressions.pas
  • source/units/Goccia.Compiler.Statements.pas
  • source/units/Goccia.Compiler.Test.pas
  • tests/language/expressions/arithmetic/self-increment-assignment.js
  • tests/language/for-loop-var/global-limit-mutation.js

Included review availability: 3 reviews are currently available. Your included PR review attempts over the past 7 days set your current allowance at 5 reviews per hour.

📝 Walkthrough

Walkthrough

The compiler now excludes const locals from numeric self-increment optimization and global-backed variables from counted-loop limit snapshots. Compiler and language tests cover const errors, mutable locals, dynamic limits, and retained increment optimization.

Changes

Compiler optimization guards

Layer / File(s) Summary
Optimization guard corrections
source/units/Goccia.Compiler.Expressions.pas, source/units/Goccia.Compiler.Statements.pas, .agent/HANDOFF.md, AGENTS.md		 Const locals use generic assignment handling. Global-backed counted-loop limits use dynamic evaluation. Optimization notes record descending loop behavior and measured guidance.
Compiler and language regression coverage
source/units/Goccia.Compiler.Test.pas, tests/language/expressions/arithmetic/self-increment-assignment.js, tests/language/for-loop-var/global-limit-mutation.js		 Tests cover const initialization and assignment errors, mutable-local OP_INC_NUMERIC emission, and global-backed limit mutation during counted loops.

Estimated code review effort: 2 (Simple) | ~10 minutes

Merge Risk: ⚪ Minimal · up to 604f0

The changes are narrowly scoped to compiler evaluation and counted-for limit behavior, with the reported test and formatting checks passing; no actionable merge-blocking risk remains beyond normal review.

🚥 Pre-merge checks | ✅ 5
✅ Passed checks (5 passed)
Check name Status Explanation
Docstring Coverage ✅ Passed No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check. Docstring coverage is scoped to functions touched by this diff. Analyzed 0 functions across 2…
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.
Title check ✅ Passed The title clearly summarizes the two primary compiler fixes: preserving const increment RHS evaluation and rechecking global-backed counted-for limits.
Description check ✅ Passed The description follows the repository template. It explains the changes, constraints, non-goals, related PR, and testing results. The optional benchmark item is unchecked, but this does not prevent a…
Full details: Docstring Coverage

Explanation

No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check. Docstring coverage is scoped to functions touched by this diff. Analyzed 0 functions across 2 files. (5 skipped: 5 unsupported.)

Full details: Description check

Explanation

The description follows the repository template. It explains the changes, constraints, non-goals, related PR, and testing results. The optional benchmark item is unchecked, but this does not prevent a pass.

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

@frostney

frostney commented Aug 27, 2026

Copy link
Copy Markdown
Owner Author

@coderabbitai review

@coderabbitai

coderabbitai Bot commented Aug 27, 2026 •
edited
Loading

Copy link
Copy Markdown
Contributor
✅ Action performed

Review finished.

Note: CodeRabbit is an incremental review system and does not re-review already reviewed commits. This command is applicable only when automatic reviews are paused.

@github-actions

github-actions Bot commented Aug 27, 2026

Copy link
Copy Markdown
Contributor

Web Tooling Benchmark

Workload Status Goccia
acorn pass 0.03 runs/s
babel pass 0.01 runs/s
babel-minify pass 0.10 runs/s
babylon pass 0.07 runs/s
buble pass 0.09 runs/s
chai pass 0.08 runs/s
coffeescript pass 0.01 runs/s
espree pass 0.02 runs/s
esprima pass 0.05 runs/s
jshint pass 0.01 runs/s
lebab pass 0.07 runs/s
postcss pass 0.02 runs/s
prepack pass 0.11 runs/s
prettier pass 0.07 runs/s
source-map pass 0.04 runs/s
terser pass 0.18 runs/s
typescript pass 0.11 runs/s
uglify-js pass 0.08 runs/s

18 pinned Web Tooling workloads; 18 workloads produced at least one Goccia sample. Raw results from 1 sample per workload; full stdout/stderr for failures and min/max/CV stay in the web-tooling-report artifact. This lane is Goccia-only by design.

@github-actions

github-actions Bot commented Aug 27, 2026

Copy link
Copy Markdown
Contributor

Benchmark Results

440 benchmarks · PR vs same-runner main build

Interpreted: 🟢 33 improved · 🔴 15 regressed · 392 unchanged · avg +1.9%
Bytecode: 🟢 38 improved · 🔴 44 regressed · 358 unchanged · avg -0.0%

Typical per-run noise (median variance): interpreted ±2.2%, bytecode ±1.9%. Deltas within noise overlap and read as unchanged.

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

Deterministic profile diff

Deterministic profile diff: no significant changes.

Measured on ubuntu-latest x64. Each PR run also builds the main base and benchmarks it back-to-back on the same runner after a warm-up discard, so the ranges compare two runs measured under the same conditions; overlapping min/max ranges are treated as unchanged noise. Percentage deltas are secondary context. See docs/adr/0076.

@github-actions

github-actions Bot commented Aug 27, 2026

Copy link
Copy Markdown
Contributor

Suite Timing

Test Runner (interpreted: 12,818 passed; bytecode: 12,818 passed)
Metric Interpreted Bytecode
Total 12818 12818
Passed 12818 ✅ 12818 ✅
Workers 4 4
Test Duration 21.24s 20.95s
Lex (cumulative) 2.08s 2.13s
Parse (cumulative) 1.12s 1.14s
Compile (cumulative) — 1.47s
Execute (cumulative) 498.9ms 19.94s
Engine Total (cumulative) 3.70s 24.68s
Lex (avg/worker) 519.7ms 533.3ms
Parse (avg/worker) 280.4ms 285.0ms
Compile (avg/worker) — 366.3ms
Execute (avg/worker) 124.7ms 4.99s
Engine Total (avg/worker) 924.9ms 6.17s

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 55.78 MiB 55.69 MiB
GC Peak Live 214.89 MiB 165.32 MiB
GC Allocated During Run 702.39 MiB 613.42 MiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 1,004 1,010
GC Collected Objects 5,502,297 4,776,029
Heap Start Allocated 372.4 KiB 372.4 KiB
Heap End Allocated 3.19 MiB 3.19 MiB
Heap Delta Allocated 2.83 MiB 2.83 MiB
Heap Delta Free 2.14 MiB 2.14 MiB
Benchmarks (interpreted: 440; bytecode: 440)
Metric Interpreted Bytecode
Total 440 440
Workers 4 4
Duration 3.15min 2.94min

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 85.0 KiB 85.0 KiB
GC Peak Live 360.43 MiB 503.67 MiB
GC Allocated During Run 19.41 GiB 17.42 GiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 5,191 6,604
GC Collected Objects 219,177,230 242,220,236
Heap Start Allocated 1.37 MiB 1.37 MiB
Heap End Allocated 1.37 MiB 1.37 MiB
Heap Delta Allocated 3.2 KiB 3.2 KiB
Boot
Metric Interpreted Bytecode
Boot (median) 7.7ms 7.8ms
Boot (min) 7.5ms 7.7ms

Empty-script (0;) end-to-end process wall-clock for GocciaScriptLoader, min and median over 60 runs after 10 warmups. Includes a fixed process / dynamic-loader floor that does not shrink, so it understates the engine-boot speedup; treat as practical boot time, not pure engine work.

Measured on ubuntu-latest x64.

@github-actions

github-actions Bot commented Aug 27, 2026

Copy link
Copy Markdown
Contributor

JetStream 3 Performance Barometer

Workload Status Goccia main Goccia PR QuickJS Node.js vs QuickJS vs Node.js
hash-map pass 0.60 0.61 13.72 340.33 22.57× 560.02×
ai-astar pass 1.61 1.62 41.38 355.87 25.52× 219.51×
gaussian-blur pass 0.37 0.36 8.20 299.13 22.50× 821.08×
raytrace-public-class-fields pass 0.46 0.46 11.49 195.75 24.97× 425.25×
sync-fs pass 0.98 0.96 26.44 220.74 27.41× 228.85×
lazy-collections pass 2.19 2.18 67.97 148.36 31.24× 68.18×

Geomean reference ratio: QuickJS 25.53×; Node.js 295.79×.

1.00× means aligned; values above 1.00× mean Goccia was proportionally slower after normalizing JetStream’s higher-is-better score. This is a directional barometer across runtimes with different goals, not a product ranking. Raw samples and failure details remain in the jetstream-report artifact.

@github-actions

github-actions Bot commented Aug 27, 2026

Copy link
Copy Markdown
Contributor

test262 Conformance

10 timeout(s) — counted separately from ordinary conformance failures; inspect the full artifact for affected tests.

Category Run Passed Δ Pass Failed Timeouts Δ Timeout Wrap-Infra Pass-rate Δ Rate
built-ins 23,812 23,719 ±0 93 0 ±0 0 99.6% ±0pp
harness 116 116 ±0 0 0 ±0 0 100.0% ±0pp
intl402 3,357 3,344 ±0 12 1 ±0 0 99.6% ±0pp
language 23,724 23,717 ±0 7 0 ±0 0 100.0% ±0pp
staging 1,483 1,389 +1 85 9 -1 0 93.7% +0.1pp
total 52,492 52,285 +1 197 10 -1 0 99.6% ±0pp

Areas closest to 100%

Area Pass rate Δ vs main Passing
language/expressions 100.0% ±0pp 11,101 / 11,102
intl402/Temporal 100.0% ±0pp 2,028 / 2,029
language/statements 99.9% ±0pp 9,341 / 9,347
Per-test deltas (+0 / -0 / timeout +0 / -1)

Resolved timeouts (1):

  • staging/sm/extensions/recursion.js

Steady-state failures and timeouts are non-blocking; PASS → non-timeout failure transitions 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.

@github-actions

github-actions Bot commented Aug 27, 2026

Copy link
Copy Markdown
Contributor

AWFY Results

Target Status Goccia main Goccia PR QuickJS 2026-06-04 NodeJS v26.8.1 Δ PR vs main
Bounce pass 18.82ms 18.95ms 1.04ms 1.12ms ~ overlap (-0.72%)
CD pass 210.44ms 209.37ms 10.69ms 9.43ms ~ overlap (+0.51%)
DeltaBlue pass 4.46ms 4.48ms 319.10µs 1.78ms ~ overlap (-0.44%)
Havlak pass 78.89s 79.14s 4036.44ms 181.59ms ~ overlap (-0.33%)
Json pass 352.07ms 350.56ms 15.18ms 4.71ms ~ overlap (+0.43%)
List pass 13.80ms 14.06ms 1.02ms 0.74ms 🔴 -1.86%
Mandelbrot pass 29.18µs 28.83µs 4.92µs 90.67µs ~ overlap (+1.17%)
NBody pass 404.03µs 425.27µs 27.88µs 392.72µs ~ overlap (-5.26%)
Permute pass 38.88ms 39.24ms 1.92ms 0.72ms ~ overlap (-0.93%)
Queens pass 20.00ms 20.21ms 1.26ms 1.04ms 🔴 -1.04%
Richards pass 643.72ms 649.25ms 52.01ms 6.95ms 🔴 -0.86%
Sieve pass 13.92ms 13.57ms 0.58ms 0.75ms 🟢 +2.53%
Storage pass 36.82ms 37.72ms 2.94ms 1.02ms 🔴 -2.44%
Towers pass 50.17ms 51.35ms 3.14ms 1.12ms 🔴 -2.36%

Geomean Ratios

Ratio (row / column) Goccia main Goccia PR QuickJS 2026-06-04 NodeJS v26.8.1
Goccia main 1.000 0.992 15.590 18.497
Goccia PR 1.008 1.000 15.717 18.647
QuickJS 2026-06-04 0.064 0.064 1.000 1.186
NodeJS v26.8.1 0.054 0.054 0.843 1.000

14 pinned AWFY benchmarks. Medians from 5 interleaved samples per engine; raw JSON includes min/max/CV and is attached as the awfy-report artifact. Δ compares PR Goccia median against the same-runner main Goccia median; overlapping min/max ranges are treated as unchanged noise. Rows below 0.5ms are timer-floor sensitive.

@frostney
frostney marked this pull request as ready for review August 27, 2026 02:10
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

No reviews

Assignees

No one assigned

Labels

None yet

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

1 participant

@frostney