chore(release): 0.10.0

[frostney]

Summary

Prepare the changelog-first GocciaScript 0.10.0 release. The runtime version is derived from the release tag, so no manifest version declaration changes.

[0.10.0] - 2026-07-21

⚡ Performance

• perf(bytecode): specialize proven numeric recursion (perf(bytecode): specialize proven numeric recursion #994)
• perf(regexp): avoid discarded match arrays (perf(regexp): avoid discarded match arrays #981)

🌐 Website

• docs(release): sync source truth and generated data (docs(release): sync source truth and generated data #995)
• refactor(website): adopt Fumadocs and Astryx (refactor(website): adopt Fumadocs and Astryx #992)
• feat(website): clarify ECMAScript compatibility positioning (feat(website): clarify ECMAScript compatibility positioning #982)

🏗️ Internal

• chore(skills): sync provisioned skills (chore(skills): sync provisioned skills #996)
• chore(skills): sync provisioned skills (chore(skills): sync provisioned skills #990)
• chore(test262): bump pin to 9e61c128 (chore(test262): bump pin to 9e61c128 #988)
• test(suite): deepen coverage and enforce structure (test(suite): deepen coverage and enforce structure #983)

🐛 Fixed

• fix(format): keep inline directives on declarations (fix(format): keep inline directives on declarations #991)
• fix(evaluator): bound lexical for-loop roots (fix(evaluator): bound lexical for-loop roots #984)
• fix(cli): preserve quoted arguments on Windows (fix(cli): preserve quoted arguments on Windows #979)

🚀 Added

• feat(delphi): support Win32 and Win64 builds (feat(delphi): support Win32 and Win64 builds #989)
• feat(engine): add capability audit events (feat(engine): add capability audit events #985)
• feat(sandbox): add Node-style fs callbacks (feat(sandbox): add Node-style fs callbacks #987)
• feat(testing): add Vitest-compatible snapshots (feat(testing): add Vitest-compatible snapshots #973)
• feat(ffi): add bidirectional ABI engine (feat(ffi): add bidirectional ABI engine #967)
• Wasm support (Wasm support #957)
• feat(modules): add configurable virtual modules (feat(modules): add configurable virtual modules #974)
• feat(engine): add deterministic and custom host environments (feat(engine): add deterministic and custom host environments #968)

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

Additional verification: clean interpreter and bytecode suites (11,519/11,519 each), Pascal formatting (429 files), website tests/lint/typecheck, and all documentation structural checks.

[vercel]

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

1 Skipped Deployment

Project	Deployment	Actions	Updated (UTC)
gocciascript-homepage	Ignored		Jul 21, 2026 1:15pm

[coderabbitai]

Warning

Review limit reached

You’ve reached a temporary PR review limit under our Fair Usage Limits Policy.

Your recent review volume is higher than typical usage, so adaptive limits are currently applied.

Next review available in: 16 minutes

Your organization has reached its usage spending cap. Adjust your spending cap in the billing tab.

How can I continue?

After more reviews become available, a review can be triggered using the @coderabbitai review command as a PR comment. Alternatively, push new commits to this PR.

To avoid repeated limits, reduce automatic review volume by pausing incremental auto-reviews earlier, using label-based review opt-in, excluding WIP or generated PR titles, or requesting reviews manually when the PR is ready. If your team needs uninterrupted high-volume reviews, an organization admin can enable usage-based reviews.

How do review limits work?

CodeRabbit enforces per-developer PR review limits for each organization. Most developers receive the normal plan review availability.

For paid Pro and Pro+ PR reviews, CodeRabbit uses adaptive limits for sustained high-volume activity. When a developer's recent PR review activity reaches the 95th percentile or higher among CodeRabbit users, additional reviews become available more gradually as earlier reviews age out of the rolling window.

Please refer docs for additional details.

Review details

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro Plus

Run ID: 6a17ab9f-b6ca-4c30-9b93-f7ac6f6467c8

📥 Commits

Reviewing files that changed from the base of the PR and between ced3610 and 0cf98f1.

📒 Files selected for processing (1)

• CHANGELOG.md

---

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

[github-actions]

Web Tooling Benchmark

Workload	Status	Goccia
acorn	pass	0.03 runs/s
babel	pass	0.01 runs/s
babel-minify	pass	0.09 runs/s
babylon	pass	0.05 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.07 runs/s
jshint	pass	0.01 runs/s
lebab	pass	0.09 runs/s
postcss	pass	0.02 runs/s
prepack	pass	0.11 runs/s
prettier	pass	0.07 runs/s
source-map	pass	0.03 runs/s
terser	pass	219 runs/s
typescript	pass	0.13 runs/s
uglify-js	pass	118 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]

Suite Timing

Test Runner (interpreted: 11,519 passed; bytecode: 11,519 passed)

Metric	Interpreted	Bytecode
Total	11519	11519
Passed	11519 ✅	11519 ✅
Workers	4	4
Test Duration	16.34s	12.82s
Lex (cumulative)	1.58s	1.33s
Parse (cumulative)	857.5ms	681.1ms
Compile (cumulative)	—	849.3ms
Execute (cumulative)	314.2ms	11.48s
Engine Total (cumulative)	2.75s	14.34s
Lex (avg/worker)	394.1ms	331.8ms
Parse (avg/worker)	214.4ms	170.3ms
Compile (avg/worker)	—	212.3ms
Execute (avg/worker)	78.6ms	2.87s
Engine Total (avg/worker)	687.0ms	3.58s

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	66.47 MiB	62.05 MiB
GC Peak Live	199.99 MiB	189.84 MiB
GC Allocated During Run	521.81 MiB	454.40 MiB
GC Limit	7.81 GiB	7.81 GiB
GC Collections	226	226
GC Collected Objects	4,377,571	3,848,594
Heap Start Allocated	326.3 KiB	326.3 KiB
Heap End Allocated	2.90 MiB	2.90 MiB
Heap Delta Allocated	2.58 MiB	2.58 MiB
Heap Delta Free	2.24 MiB	2.24 MiB

Benchmarks (interpreted: 439; bytecode: 439)

Metric	Interpreted	Bytecode
Total	439	439
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	808 B	808 B
GC Peak Live	140.76 MiB	61.47 MiB
GC Allocated During Run	15.83 GiB	9.47 GiB
GC Limit	7.81 GiB	7.81 GiB
GC Collections	5,480	6,609
GC Collected Objects	231,550,535	211,358,152
Heap Start Allocated	1.36 MiB	1.36 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.3ms	7.5ms
Boot (min)	7.2ms	7.3ms

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]

Benchmark Results

439 benchmarks · PR vs same-runner main build

Interpreted: 🟢 30 improved · 🔴 24 regressed · 385 unchanged · avg +0.6%
Bytecode: 🟢 50 improved · 🔴 34 regressed · 355 unchanged · avg +0.7%

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

arraybuffer.js — Interp: 14 unch. · avg +0.6% · Bytecode: 🟢 1, 🔴 1, 12 unch. · avg +0.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
create ArrayBuffer(0)	90,460 ops/sec [86,322..100,040] → 95,566 ops/sec [90,263..98,442]	~ overlap (+5.6%)	145,478 ops/sec [143,492..148,978] → 146,563 ops/sec [90,063..213,834]	~ overlap (+0.7%)
create ArrayBuffer(64)	97,445 ops/sec [94,591..128,451] → 95,337 ops/sec [92,962..105,759]	~ overlap (-2.2%)	141,892 ops/sec [139,160..143,145] → 145,189 ops/sec [138,030..158,791]	~ overlap (+2.3%)
create ArrayBuffer(1024)	89,265 ops/sec [87,653..91,086] → 88,243 ops/sec [84,754..88,649]	~ overlap (-1.1%)	123,782 ops/sec [123,347..126,278] → 126,143 ops/sec [123,350..127,181]	~ overlap (+1.9%)
create ArrayBuffer(8192)	57,732 ops/sec [57,007..58,430] → 59,344 ops/sec [57,077..62,286]	~ overlap (+2.8%)	76,286 ops/sec [74,357..76,935] → 74,336 ops/sec [74,145..75,830]	~ overlap (-2.6%)
slice full buffer (64 bytes)	71,860 ops/sec [71,429..73,546] → 73,598 ops/sec [71,743..73,750]	~ overlap (+2.4%)	93,885 ops/sec [89,035..96,837] → 89,911 ops/sec [89,353..91,181]	~ overlap (-4.2%)
slice half buffer (512 of 1024 bytes)	67,469 ops/sec [66,199..70,054] → 69,520 ops/sec [67,954..78,315]	~ overlap (+3.0%)	86,011 ops/sec [84,691..87,869] → 83,713 ops/sec [82,829..84,820]	~ overlap (-2.7%)
slice with negative indices	64,398 ops/sec [62,566..67,688] → 64,618 ops/sec [62,172..71,964]	~ overlap (+0.3%)	86,604 ops/sec [84,149..103,176] → 85,566 ops/sec [82,831..86,251]	~ overlap (-1.2%)
slice empty range	71,463 ops/sec [69,250..75,775] → 70,028 ops/sec [69,246..72,795]	~ overlap (-2.0%)	87,005 ops/sec [86,462..87,272] → 85,730 ops/sec [85,143..86,561]	~ overlap (-1.5%)
byteLength access	180,349 ops/sec [177,936..181,192] → 180,369 ops/sec [172,430..181,241]	~ overlap (+0.0%)	237,856 ops/sec [237,146..285,625] → 231,523 ops/sec [226,435..249,659]	~ overlap (-2.7%)
Symbol.toStringTag access	177,113 ops/sec [176,724..177,834] → 178,061 ops/sec [175,704..197,762]	~ overlap (+0.5%)	224,262 ops/sec [223,372..245,975] → 218,779 ops/sec [216,349..219,412]	🔴 -2.4%
ArrayBuffer.isView	135,227 ops/sec [133,625..136,266] → 133,716 ops/sec [130,066..134,000]	~ overlap (-1.1%)	197,065 ops/sec [191,856..202,842] → 215,753 ops/sec [212,274..230,975]	🟢 +9.5%
clone ArrayBuffer(64)	106,297 ops/sec [105,326..137,114] → 106,187 ops/sec [104,068..107,302]	~ overlap (-0.1%)	148,792 ops/sec [147,175..150,541] → 156,790 ops/sec [149,267..175,838]	~ overlap (+5.4%)
clone ArrayBuffer(1024)	97,588 ops/sec [95,025..102,233] → 97,549 ops/sec [94,423..100,292]	~ overlap (-0.0%)	128,893 ops/sec [126,446..129,805] → 130,426 ops/sec [128,190..143,903]	~ overlap (+1.2%)
clone ArrayBuffer inside object	69,257 ops/sec [68,188..71,548] → 69,559 ops/sec [68,019..69,744]	~ overlap (+0.4%)	86,668 ops/sec [85,551..87,685] → 94,426 ops/sec [85,974..100,899]	~ overlap (+9.0%)

arrays.js — Interp: 19 unch. · avg -0.2% · Bytecode: 🟢 3, 🔴 4, 12 unch. · avg +0.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Array.from length 100	2,294 ops/sec [2,059..2,466] → 2,254 ops/sec [2,222..2,289]	~ overlap (-1.7%)	2,019 ops/sec [1,995..2,539] → 1,989 ops/sec [1,747..2,037]	~ overlap (-1.5%)
Array.from 10 elements	14,165 ops/sec [14,082..14,859] → 14,727 ops/sec [14,117..17,850]	~ overlap (+4.0%)	15,038 ops/sec [14,955..16,186] → 15,158 ops/sec [14,836..15,527]	~ overlap (+0.8%)
Array.of 10 elements	52,116 ops/sec [46,268..55,881] → 46,600 ops/sec [43,856..52,284]	~ overlap (-10.6%)	54,662 ops/sec [53,908..58,703] → 55,807 ops/sec [54,153..61,894]	~ overlap (+2.1%)
spread into new array	70,383 ops/sec [69,085..71,673] → 71,736 ops/sec [70,933..80,455]	~ overlap (+1.9%)	42,227 ops/sec [41,897..42,722] → 41,312 ops/sec [41,086..41,868]	🔴 -2.2%
map over 50 elements	3,904 ops/sec [3,767..5,107] → 3,973 ops/sec [3,945..3,981]	~ overlap (+1.8%)	4,214 ops/sec [4,180..4,220] → 4,233 ops/sec [4,222..4,247]	🟢 +0.4%
filter over 50 elements	4,019 ops/sec [3,929..4,172] → 3,996 ops/sec [3,957..4,050]	~ overlap (-0.6%)	4,569 ops/sec [4,395..4,574] → 4,618 ops/sec [4,600..4,623]	🟢 +1.1%
reduce sum 50 elements	4,626 ops/sec [4,502..4,653] → 4,642 ops/sec [4,579..4,702]	~ overlap (+0.3%)	5,054 ops/sec [5,018..5,088] → 5,043 ops/sec [4,937..5,070]	~ overlap (-0.2%)
forEach over 50 elements	3,250 ops/sec [3,223..3,303] → 3,268 ops/sec [3,238..3,652]	~ overlap (+0.5%)	5,421 ops/sec [5,375..5,493] → 5,302 ops/sec [5,237..5,327]	🔴 -2.2%
find in 50 elements	6,381 ops/sec [5,212..6,513] → 6,605 ops/sec [6,356..7,424]	~ overlap (+3.5%)	6,677 ops/sec [6,510..6,750] → 6,654 ops/sec [6,611..6,756]	~ overlap (-0.4%)
sort 20 elements	3,459 ops/sec [3,432..3,493] → 3,473 ops/sec [3,417..3,518]	~ overlap (+0.4%)	3,734 ops/sec [3,721..3,889] → 3,968 ops/sec [3,854..4,001]	~ overlap (+6.3%)
flat nested array	28,508 ops/sec [26,892..32,353] → 26,945 ops/sec [26,680..27,041]	~ overlap (-5.5%)	30,365 ops/sec [30,091..35,678] → 31,380 ops/sec [31,210..32,090]	~ overlap (+3.3%)
flatMap	15,845 ops/sec [15,780..16,021] → 16,015 ops/sec [15,946..17,220]	~ overlap (+1.1%)	17,531 ops/sec [17,371..17,767] → 17,931 ops/sec [17,581..17,952]	~ overlap (+2.3%)
map inside map (5x5)	4,747 ops/sec [4,699..4,797] → 4,661 ops/sec [4,603..4,772]	~ overlap (-1.8%)	4,932 ops/sec [4,887..5,002] → 5,163 ops/sec [5,144..5,176]	🟢 +4.7%
filter inside map (5x10)	3,069 ops/sec [3,033..3,119] → 3,023 ops/sec [2,996..3,060]	~ overlap (-1.5%)	3,500 ops/sec [3,398..3,519] → 3,479 ops/sec [3,453..3,500]	~ overlap (-0.6%)
reduce inside map (5x10)	3,601 ops/sec [3,545..3,887] → 3,561 ops/sec [3,543..3,647]	~ overlap (-1.1%)	3,993 ops/sec [3,963..4,037] → 4,001 ops/sec [3,946..4,031]	~ overlap (+0.2%)
forEach inside forEach (5x10)	2,744 ops/sec [2,627..2,757] → 2,737 ops/sec [2,724..3,187]	~ overlap (-0.3%)	4,362 ops/sec [4,263..4,427] → 4,369 ops/sec [4,322..4,520]	~ overlap (+0.2%)
find inside some (10x10)	2,745 ops/sec [2,717..2,841] → 2,843 ops/sec [2,748..2,912]	~ overlap (+3.6%)	3,104 ops/sec [3,072..3,225] → 3,008 ops/sec [2,972..3,060]	🔴 -3.1%
map+filter chain nested (5x20)	907 ops/sec [836..1,059] → 919 ops/sec [883..934]	~ overlap (+1.3%)	1,037 ops/sec [1,029..1,041] → 1,000 ops/sec [987..1,008]	🔴 -3.5%
reduce flatten (10x5)	6,648 ops/sec [6,572..6,902] → 6,705 ops/sec [6,541..6,760]	~ overlap (+0.9%)	2,827 ops/sec [2,820..2,865] → 2,835 ops/sec [2,714..3,023]	~ overlap (+0.3%)

async-await.js — Interp: 🟢 1, 5 unch. · avg +5.4% · Bytecode: 6 unch. · avg +0.7%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
single await	20,198 ops/sec [18,013..24,538] → 21,796 ops/sec [18,021..25,814]	~ overlap (+7.9%)	24,767 ops/sec [24,024..26,047] → 24,656 ops/sec [21,087..28,373]	~ overlap (-0.4%)
multiple awaits	8,247 ops/sec [8,183..8,295] → 8,308 ops/sec [8,171..8,657]	~ overlap (+0.7%)	8,715 ops/sec [8,631..8,829] → 8,937 ops/sec [8,814..10,877]	~ overlap (+2.5%)
await non-Promise value	28,527 ops/sec [27,964..30,944] → 29,439 ops/sec [27,975..29,641]	~ overlap (+3.2%)	35,226 ops/sec [34,263..35,420] → 36,345 ops/sec [35,357..55,984]	~ overlap (+3.2%)
await with try/catch	17,274 ops/sec [17,115..18,469] → 18,361 ops/sec [17,356..20,078]	~ overlap (+6.3%)	24,027 ops/sec [23,459..25,470] → 23,311 ops/sec [23,030..23,514]	~ overlap (-3.0%)
await Promise.all	4,905 ops/sec [4,448..5,018] → 4,892 ops/sec [4,526..5,571]	~ overlap (-0.3%)	5,149 ops/sec [5,097..5,275] → 5,247 ops/sec [5,041..5,404]	~ overlap (+1.9%)
nested async function call	11,003 ops/sec [10,466..11,639] → 12,614 ops/sec [11,777..13,235]	🟢 +14.6%	14,604 ops/sec [14,564..14,607] → 14,586 ops/sec [14,549..14,638]	~ overlap (-0.1%)

async-generators.js — Interp: 2 unch. · avg -3.3% · Bytecode: 2 unch. · avg +1.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for-await-of over async generator	1,257 ops/sec [1,230..1,282] → 1,315 ops/sec [1,267..1,362]	~ overlap (+4.6%)	591 ops/sec [585..646] → 601 ops/sec [581..656]	~ overlap (+1.7%)
async generator with await in body	6,026 ops/sec [4,792..6,099] → 5,350 ops/sec [5,131..5,834]	~ overlap (-11.2%)	4,442 ops/sec [4,345..4,780] → 4,537 ops/sec [4,445..4,939]	~ overlap (+2.1%)

atomics.js — Interp: 6 unch. · avg +0.1% · Bytecode: 6 unch. · avg -0.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
load and store Int32Array	67,026 ops/sec [66,238..68,377] → 67,149 ops/sec [66,275..70,131]	~ overlap (+0.2%)	104,552 ops/sec [102,004..104,771] → 104,602 ops/sec [103,730..106,139]	~ overlap (+0.0%)
read-modify-write Int32Array	48,425 ops/sec [47,954..49,771] → 50,449 ops/sec [48,406..58,098]	~ overlap (+4.2%)	71,810 ops/sec [69,643..72,261] → 71,332 ops/sec [70,731..72,208]	~ overlap (-0.7%)
compareExchange hit and miss	46,127 ops/sec [45,100..46,364] → 46,252 ops/sec [45,230..47,742]	~ overlap (+0.3%)	67,665 ops/sec [67,449..68,056] → 67,779 ops/sec [67,335..67,815]	~ overlap (+0.2%)
wait with zero timeout	113,116 ops/sec [112,440..114,990] → 111,441 ops/sec [108,758..124,054]	~ overlap (-1.5%)	184,534 ops/sec [162,442..200,887] → 176,152 ops/sec [174,772..204,630]	~ overlap (-4.5%)
waitAsync synchronous not-equal	82,932 ops/sec [81,867..85,209] → 81,605 ops/sec [78,736..83,439]	~ overlap (-1.6%)	111,088 ops/sec [110,377..114,749] → 115,189 ops/sec [114,743..121,813]	~ overlap (+3.7%)
notify with no waiters	113,559 ops/sec [111,886..114,769] → 112,366 ops/sec [109,842..114,592]	~ overlap (-1.1%)	176,768 ops/sec [174,770..177,217] → 174,559 ops/sec [174,224..191,583]	~ overlap (-1.2%)

base64.js — Interp: 10 unch. · avg -0.0% · Bytecode: 10 unch. · avg +0.8%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
short ASCII (13 chars)	2,038 ops/sec [2,024..2,040] → 1,977 ops/sec [1,926..2,074]	~ overlap (-3.0%)	1,976 ops/sec [1,899..2,030] → 1,977 ops/sec [1,931..1,992]	~ overlap (+0.1%)
medium ASCII (450 chars)	73 ops/sec [73..74] → 72 ops/sec [70..84]	~ overlap (-1.7%)	72 ops/sec [70..73] → 72 ops/sec [71..73]	~ overlap (+0.3%)
Latin-1 characters	2,935 ops/sec [2,878..2,989] → 2,945 ops/sec [2,940..2,953]	~ overlap (+0.3%)	2,963 ops/sec [2,901..2,995] → 2,900 ops/sec [2,860..2,938]	~ overlap (-2.1%)
short base64 (20 chars)	1,495 ops/sec [1,453..1,499] → 1,474 ops/sec [1,466..1,480]	~ overlap (-1.4%)	1,477 ops/sec [1,460..1,479] → 1,470 ops/sec [1,437..1,507]	~ overlap (-0.5%)
medium base64 (600 chars)	58 ops/sec [58..59] → 58 ops/sec [58..64]	~ overlap (+0.6%)	57 ops/sec [56..64] → 57 ops/sec [56..58]	~ overlap (+0.9%)
Latin-1 output	2,154 ops/sec [2,134..2,175] → 2,173 ops/sec [2,099..2,463]	~ overlap (+0.9%)	2,067 ops/sec [2,055..2,090] → 2,113 ops/sec [2,049..2,119]	~ overlap (+2.2%)
forgiving (no padding)	3,143 ops/sec [3,126..3,697] → 3,102 ops/sec [3,049..3,180]	~ overlap (-1.3%)	3,003 ops/sec [2,993..3,034] → 3,079 ops/sec [3,030..3,155]	~ overlap (+2.5%)
with whitespace	1,454 ops/sec [1,417..1,716] → 1,526 ops/sec [1,428..1,658]	~ overlap (+5.0%)	1,442 ops/sec [1,432..1,456] → 1,437 ops/sec [1,418..1,438]	~ overlap (-0.4%)
atob(btoa(short))	838 ops/sec [832..963] → 851 ops/sec [828..878]	~ overlap (+1.5%)	855 ops/sec [840..880] → 870 ops/sec [849..889]	~ overlap (+1.7%)
atob(btoa(medium))	33 ops/sec [31..36] → 33 ops/sec [32..35]	~ overlap (-1.2%)	32 ops/sec [31..32] → 33 ops/sec [32..35]	~ overlap (+3.8%)

classes.js — Interp: 🟢 2, 🔴 1, 28 unch. · avg -0.4% · Bytecode: 🟢 3, 🔴 1, 27 unch. · avg -0.5%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple class new	32,121 ops/sec [31,870..33,369] → 33,162 ops/sec [32,475..35,078]	~ overlap (+3.2%)	48,805 ops/sec [48,711..48,831] → 50,287 ops/sec [49,569..51,536]	🟢 +3.0%
class with defaults	26,058 ops/sec [25,809..30,643] → 25,979 ops/sec [24,396..27,110]	~ overlap (-0.3%)	35,811 ops/sec [33,257..39,370] → 33,533 ops/sec [32,948..34,793]	~ overlap (-6.4%)
50 instances via Array.from	1,173 ops/sec [1,165..1,214] → 1,204 ops/sec [1,155..1,415]	~ overlap (+2.7%)	1,362 ops/sec [1,279..1,513] → 1,313 ops/sec [1,293..1,327]	~ overlap (-3.6%)
instance method call	15,486 ops/sec [15,334..17,293] → 15,311 ops/sec [15,199..15,394]	~ overlap (-1.1%)	25,732 ops/sec [24,868..27,292] → 25,836 ops/sec [25,649..25,965]	~ overlap (+0.4%)
static method call	26,284 ops/sec [26,064..28,388] → 26,000 ops/sec [25,790..26,075]	~ overlap (-1.1%)	57,538 ops/sec [53,530..58,356] → 53,212 ops/sec [51,762..53,493]	🔴 -7.5%
single-level inheritance	13,369 ops/sec [13,302..15,710] → 13,205 ops/sec [13,042..13,511]	~ overlap (-1.2%)	17,819 ops/sec [17,513..19,040] → 17,988 ops/sec [17,346..18,509]	~ overlap (+1.0%)
two-level inheritance	12,557 ops/sec [11,812..13,207] → 11,762 ops/sec [11,487..12,020]	~ overlap (-6.3%)	13,630 ops/sec [13,401..13,880] → 14,416 ops/sec [14,252..14,599]	🟢 +5.8%
private field access	16,158 ops/sec [15,914..16,540] → 16,523 ops/sec [15,789..16,588]	~ overlap (+2.3%)	11,808 ops/sec [11,697..11,822] → 11,705 ops/sec [11,520..11,844]	~ overlap (-0.9%)
private methods	19,416 ops/sec [17,837..19,763] → 18,378 ops/sec [18,153..19,043]	~ overlap (-5.3%)	12,364 ops/sec [12,159..12,371] → 12,237 ops/sec [11,763..12,862]	~ overlap (-1.0%)
getter/setter access	17,839 ops/sec [17,559..17,908] → 18,088 ops/sec [17,788..21,228]	~ overlap (+1.4%)	28,935 ops/sec [27,744..33,465] → 27,425 ops/sec [27,244..32,529]	~ overlap (-5.2%)
class decorator (identity)	28,482 ops/sec [26,544..31,310] → 26,975 ops/sec [26,653..28,382]	~ overlap (-5.3%)	31,472 ops/sec [30,618..38,295] → 32,156 ops/sec [29,989..34,537]	~ overlap (+2.2%)
class decorator (wrapping)	15,644 ops/sec [15,146..15,784] → 15,427 ops/sec [15,086..15,742]	~ overlap (-1.4%)	17,120 ops/sec [16,119..18,964] → 16,649 ops/sec [16,420..16,742]	~ overlap (-2.8%)
identity method decorator	19,503 ops/sec [19,005..21,212] → 19,673 ops/sec [19,534..19,701]	~ overlap (+0.9%)	25,291 ops/sec [24,334..26,148] → 27,272 ops/sec [24,712..32,462]	~ overlap (+7.8%)
wrapping method decorator	16,029 ops/sec [15,114..16,759] → 16,915 ops/sec [15,510..19,021]	~ overlap (+5.5%)	18,270 ops/sec [18,065..18,894] → 18,191 ops/sec [17,752..20,624]	~ overlap (-0.4%)
stacked method decorators (x3)	11,473 ops/sec [11,425..11,549] → 11,541 ops/sec [11,386..12,881]	~ overlap (+0.6%)	13,353 ops/sec [13,131..13,844] → 12,740 ops/sec [11,574..13,654]	~ overlap (-4.6%)
identity field decorator	22,598 ops/sec [21,930..25,342] → 22,762 ops/sec [22,617..24,092]	~ overlap (+0.7%)	23,665 ops/sec [23,212..23,809] → 24,050 ops/sec [23,610..24,318]	~ overlap (+1.6%)
field initializer decorator	18,730 ops/sec [18,593..18,881] → 19,187 ops/sec [19,044..26,541]	🟢 +2.4%	21,954 ops/sec [20,459..22,693] → 21,835 ops/sec [20,664..22,037]	~ overlap (-0.5%)
getter decorator (identity)	17,537 ops/sec [17,336..19,426] → 17,462 ops/sec [17,103..17,636]	~ overlap (-0.4%)	15,323 ops/sec [14,854..15,809] → 15,029 ops/sec [14,814..15,724]	~ overlap (-1.9%)
setter decorator (identity)	16,189 ops/sec [15,870..16,285] → 14,339 ops/sec [13,999..14,744]	🔴 -11.4%	12,283 ops/sec [12,163..12,682] → 12,042 ops/sec [11,335..12,288]	~ overlap (-2.0%)
static method decorator	21,997 ops/sec [20,876..22,577] → 20,881 ops/sec [20,030..22,369]	~ overlap (-5.1%)	28,459 ops/sec [28,013..28,534] → 29,209 ops/sec [27,908..31,274]	~ overlap (+2.6%)
static field decorator	26,279 ops/sec [24,468..27,653] → 25,211 ops/sec [24,715..27,026]	~ overlap (-4.1%)	30,343 ops/sec [30,204..33,467] → 31,431 ops/sec [29,216..33,203]	~ overlap (+3.6%)
private method decorator	15,000 ops/sec [14,896..15,095] → 15,214 ops/sec [14,876..15,847]	~ overlap (+1.4%)	16,410 ops/sec [16,090..17,992] → 16,652 ops/sec [15,680..17,832]	~ overlap (+1.5%)
private field decorator	16,424 ops/sec [16,363..16,676] → 16,738 ops/sec [16,644..16,786]	~ overlap (+1.9%)	15,581 ops/sec [15,011..21,185] → 14,326 ops/sec [13,427..16,962]	~ overlap (-8.1%)
plain auto-accessor (no decorator)	29,006 ops/sec [28,434..29,616] → 28,743 ops/sec [28,320..31,201]	~ overlap (-0.9%)	31,028 ops/sec [30,842..31,292] → 30,822 ops/sec [30,166..31,475]	~ overlap (-0.7%)
auto-accessor with decorator	16,773 ops/sec [16,567..16,948] → 17,261 ops/sec [16,822..21,852]	~ overlap (+2.9%)	18,076 ops/sec [17,743..18,196] → 17,902 ops/sec [17,466..18,857]	~ overlap (-1.0%)
decorator writing metadata	14,525 ops/sec [14,228..14,717] → 14,203 ops/sec [14,029..14,455]	~ overlap (-2.2%)	17,452 ops/sec [16,978..18,502] → 17,476 ops/sec [16,310..19,417]	~ overlap (+0.1%)
static getter read	30,523 ops/sec [30,339..31,534] → 32,199 ops/sec [31,276..34,877]	~ overlap (+5.5%)	50,810 ops/sec [47,353..53,821] → 52,077 ops/sec [51,492..53,046]	~ overlap (+2.5%)
static getter/setter pair	23,005 ops/sec [22,433..30,743] → 22,890 ops/sec [22,465..27,226]	~ overlap (-0.5%)	37,026 ops/sec [36,625..37,577] → 36,228 ops/sec [35,618..38,249]	~ overlap (-2.2%)
inherited static getter	18,921 ops/sec [18,695..19,013] → 19,317 ops/sec [19,073..20,582]	🟢 +2.1%	29,604 ops/sec [28,776..29,965] → 30,465 ops/sec [29,797..30,770]	~ overlap (+2.9%)
inherited static setter	21,040 ops/sec [20,650..21,167] → 20,921 ops/sec [20,372..22,691]	~ overlap (-0.6%)	32,453 ops/sec [29,127..37,503] → 31,324 ops/sec [30,808..31,488]	~ overlap (-3.5%)
inherited static getter with this binding	16,142 ops/sec [16,008..16,293] → 16,376 ops/sec [15,431..18,673]	~ overlap (+1.4%)	23,334 ops/sec [23,143..23,356] → 24,024 ops/sec [23,767..24,199]	🟢 +3.0%

closures.js — Interp: 11 unch. · avg -0.7% · Bytecode: 11 unch. · avg -0.3%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
closure over single variable	24,481 ops/sec [24,211..25,188] → 24,491 ops/sec [24,087..24,696]	~ overlap (+0.0%)	92,091 ops/sec [89,682..104,019] → 91,076 ops/sec [88,226..107,370]	~ overlap (-1.1%)
closure over multiple variables	28,678 ops/sec [28,534..29,224] → 29,096 ops/sec [28,628..32,108]	~ overlap (+1.5%)	91,592 ops/sec [87,307..93,945] → 90,521 ops/sec [90,241..93,574]	~ overlap (-1.2%)
nested closures	32,387 ops/sec [32,125..32,517] → 31,848 ops/sec [31,464..32,651]	~ overlap (-1.7%)	85,546 ops/sec [83,321..85,854] → 86,107 ops/sec [83,221..86,696]	~ overlap (+0.7%)
function as argument	23,519 ops/sec [22,796..24,036] → 23,307 ops/sec [23,069..23,626]	~ overlap (-0.9%)	83,840 ops/sec [83,150..92,846] → 84,078 ops/sec [80,624..98,170]	~ overlap (+0.3%)
function returning function	29,694 ops/sec [28,789..29,986] → 28,988 ops/sec [28,796..29,332]	~ overlap (-2.4%)	93,934 ops/sec [93,463..95,381] → 95,452 ops/sec [95,162..95,845]	~ overlap (+1.6%)
compose two functions	21,082 ops/sec [19,248..24,643] → 19,593 ops/sec [18,739..28,939]	~ overlap (-7.1%)	56,485 ops/sec [51,638..57,095] → 58,354 ops/sec [56,089..69,327]	~ overlap (+3.3%)
fn.call	39,948 ops/sec [39,202..45,630] → 39,504 ops/sec [39,286..39,771]	~ overlap (-1.1%)	86,260 ops/sec [81,889..87,016] → 87,391 ops/sec [80,876..88,619]	~ overlap (+1.3%)
fn.apply	32,180 ops/sec [31,808..32,674] → 33,607 ops/sec [31,190..38,307]	~ overlap (+4.4%)	69,637 ops/sec [68,255..70,908] → 68,631 ops/sec [67,668..72,073]	~ overlap (-1.4%)
fn.bind	33,452 ops/sec [32,555..34,341] → 34,581 ops/sec [33,862..39,248]	~ overlap (+3.4%)	91,933 ops/sec [89,335..114,654] → 92,357 ops/sec [88,820..93,583]	~ overlap (+0.5%)
recursive sum to 50	2,919 ops/sec [2,861..2,941] → 2,909 ops/sec [2,860..3,237]	~ overlap (-0.4%)	43,030 ops/sec [42,018..59,807] → 42,436 ops/sec [42,091..43,513]	~ overlap (-1.4%)
recursive tree traversal	4,679 ops/sec [4,346..5,033] → 4,519 ops/sec [4,504..4,552]	~ overlap (-3.4%)	12,338 ops/sec [11,933..12,753] → 11,629 ops/sec [11,048..12,926]	~ overlap (-5.7%)

collections.js — Interp: 🔴 1, 11 unch. · avg -2.3% · Bytecode: 🔴 2, 10 unch. · avg -3.3%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
add 50 elements	2,523 ops/sec [2,512..2,552] → 2,537 ops/sec [2,516..2,567]	~ overlap (+0.5%)	3,134 ops/sec [3,118..3,357] → 3,106 ops/sec [3,101..3,490]	~ overlap (-0.9%)
has lookup (50 elements)	54,133 ops/sec [45,828..60,222] → 44,949 ops/sec [43,054..46,982]	~ overlap (-17.0%)	79,977 ops/sec [77,889..89,288] → 79,802 ops/sec [77,573..112,367]	~ overlap (-0.2%)
delete elements	13,972 ops/sec [13,276..14,230] → 13,408 ops/sec [13,019..13,457]	~ overlap (-4.0%)	15,980 ops/sec [15,436..17,818] → 15,660 ops/sec [15,420..18,530]	~ overlap (-2.0%)
forEach iteration	3,515 ops/sec [3,466..4,313] → 3,493 ops/sec [3,466..3,564]	~ overlap (-0.6%)	6,983 ops/sec [5,690..7,283] → 5,856 ops/sec [5,677..6,907]	~ overlap (-16.1%)
spread to array	10,120 ops/sec [9,864..10,350] → 11,115 ops/sec [10,245..12,937]	~ overlap (+9.8%)	50,377 ops/sec [49,208..65,878] → 50,793 ops/sec [48,716..57,316]	~ overlap (+0.8%)
deduplicate array	9,983 ops/sec [9,839..10,137] → 9,769 ops/sec [9,574..10,074]	~ overlap (-2.1%)	14,973 ops/sec [12,855..15,535] → 14,602 ops/sec [14,213..14,690]	~ overlap (-2.5%)
set 50 entries	1,953 ops/sec [1,925..2,001] → 1,974 ops/sec [1,951..1,987]	~ overlap (+1.0%)	2,556 ops/sec [2,472..2,585] → 2,574 ops/sec [2,550..2,612]	~ overlap (+0.7%)
get lookup (50 entries)	47,147 ops/sec [46,414..47,782] → 46,931 ops/sec [46,284..47,423]	~ overlap (-0.5%)	72,920 ops/sec [71,191..76,969] → 72,578 ops/sec [69,532..81,706]	~ overlap (-0.5%)
has check	64,874 ops/sec [61,626..76,878] → 60,454 ops/sec [59,554..61,268]	🔴 -6.8%	94,361 ops/sec [92,014..95,496] → 92,951 ops/sec [85,768..108,831]	~ overlap (-1.5%)
delete entries	11,840 ops/sec [11,662..12,157] → 11,871 ops/sec [11,759..11,965]	~ overlap (+0.3%)	13,852 ops/sec [13,563..16,085] → 13,176 ops/sec [13,064..13,239]	🔴 -4.9%
forEach iteration	3,476 ops/sec [3,455..3,889] → 3,509 ops/sec [3,415..3,691]	~ overlap (+1.0%)	5,834 ops/sec [5,803..5,965] → 5,566 ops/sec [5,354..5,658]	🔴 -4.6%
keys/values/entries	3,214 ops/sec [2,882..3,325] → 2,904 ops/sec [2,800..2,934]	~ overlap (-9.7%)	10,119 ops/sec [8,957..12,744] → 9,350 ops/sec [9,259..9,389]	~ overlap (-7.6%)

csv.js — Interp: 13 unch. · avg +0.7% · Bytecode: 13 unch. · avg +0.5%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple 3-column CSV	38,416 ops/sec [37,883..38,865] → 38,689 ops/sec [37,856..40,692]	~ overlap (+0.7%)	37,383 ops/sec [37,118..37,913] → 37,697 ops/sec [36,813..38,428]	~ overlap (+0.8%)
parse 10-row CSV	11,136 ops/sec [11,025..12,443] → 11,192 ops/sec [11,014..11,264]	~ overlap (+0.5%)	11,478 ops/sec [11,222..11,665] → 11,364 ops/sec [11,221..14,828]	~ overlap (-1.0%)
parse 100-row CSV	1,800 ops/sec [1,740..1,955] → 2,014 ops/sec [1,777..2,162]	~ overlap (+11.9%)	1,816 ops/sec [1,768..2,081] → 1,774 ops/sec [1,760..1,998]	~ overlap (-2.3%)
parse CSV with quoted fields	57,869 ops/sec [57,135..64,252] → 57,563 ops/sec [56,455..60,588]	~ overlap (-0.5%)	54,160 ops/sec [53,009..54,558] → 55,009 ops/sec [53,513..55,097]	~ overlap (+1.6%)
parse without headers (array of arrays)	5,452 ops/sec [5,402..5,861] → 5,592 ops/sec [5,424..5,871]	~ overlap (+2.6%)	5,394 ops/sec [5,188..5,445] → 5,457 ops/sec [5,363..6,314]	~ overlap (+1.2%)
parse with semicolon delimiter	8,664 ops/sec [8,150..9,301] → 8,777 ops/sec [8,250..10,156]	~ overlap (+1.3%)	8,373 ops/sec [8,240..9,211] → 8,285 ops/sec [8,055..8,602]	~ overlap (-1.1%)
stringify array of objects	40,677 ops/sec [40,392..41,238] → 40,861 ops/sec [40,639..41,208]	~ overlap (+0.5%)	43,189 ops/sec [42,783..49,483] → 42,676 ops/sec [42,009..43,628]	~ overlap (-1.2%)
stringify array of arrays	18,026 ops/sec [17,710..18,377] → 17,840 ops/sec [17,490..18,354]	~ overlap (-1.0%)	17,499 ops/sec [17,211..17,525] → 17,409 ops/sec [16,534..17,561]	~ overlap (-0.5%)
stringify with values needing escaping	23,487 ops/sec [22,907..25,038] → 22,893 ops/sec [21,428..23,575]	~ overlap (-2.5%)	23,443 ops/sec [22,559..26,073] → 23,241 ops/sec [22,780..29,386]	~ overlap (-0.9%)
reviver converts numbers	534 ops/sec [514..626] → 532 ops/sec [530..629]	~ overlap (-0.4%)	611 ops/sec [605..613] → 619 ops/sec [606..651]	~ overlap (+1.4%)
reviver filters empty to null	7,039 ops/sec [6,978..7,087] → 7,018 ops/sec [6,841..7,154]	~ overlap (-0.3%)	9,204 ops/sec [9,010..9,948] → 9,628 ops/sec [9,411..11,264]	~ overlap (+4.6%)
parse then stringify	6,801 ops/sec [6,467..7,847] → 6,648 ops/sec [6,592..6,664]	~ overlap (-2.2%)	6,688 ops/sec [6,476..7,314] → 6,572 ops/sec [6,357..6,737]	~ overlap (-1.7%)
stringify then parse	6,594 ops/sec [6,389..7,078] → 6,548 ops/sec [6,452..6,566]	~ overlap (-0.7%)	6,840 ops/sec [5,456..7,707] → 7,195 ops/sec [6,663..7,793]	~ overlap (+5.2%)

destructuring.js — Interp: 🟢 2, 20 unch. · avg +1.4% · Bytecode: 🟢 2, 🔴 1, 19 unch. · avg -0.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple array destructuring	51,174 ops/sec [49,641..54,315] → 52,666 ops/sec [50,584..54,671]	~ overlap (+2.9%)	72,268 ops/sec [71,314..72,396] → 71,364 ops/sec [69,049..72,612]	~ overlap (-1.3%)
with rest element	43,989 ops/sec [42,331..44,422] → 44,228 ops/sec [42,864..44,743]	~ overlap (+0.5%)	56,503 ops/sec [55,688..58,672] → 54,680 ops/sec [53,834..56,894]	~ overlap (-3.2%)
with defaults	53,965 ops/sec [53,688..58,333] → 53,928 ops/sec [51,842..55,130]	~ overlap (-0.1%)	75,083 ops/sec [74,152..75,365] → 75,603 ops/sec [74,814..80,173]	~ overlap (+0.7%)
skip elements	59,546 ops/sec [58,996..59,587] → 58,840 ops/sec [57,360..66,261]	~ overlap (-1.2%)	77,741 ops/sec [76,913..78,881] → 78,103 ops/sec [75,504..79,070]	~ overlap (+0.5%)
nested array destructuring	24,798 ops/sec [24,192..25,126] → 24,609 ops/sec [24,172..26,495]	~ overlap (-0.8%)	28,514 ops/sec [28,385..28,674] → 30,246 ops/sec [27,192..31,584]	~ overlap (+6.1%)
swap variables	72,313 ops/sec [69,754..72,879] → 70,788 ops/sec [69,963..73,716]	~ overlap (-2.1%)	116,608 ops/sec [116,549..116,735] → 114,131 ops/sec [107,570..128,807]	~ overlap (-2.1%)
simple object destructuring	62,882 ops/sec [61,980..63,359] → 63,785 ops/sec [62,350..64,905]	~ overlap (+1.4%)	94,097 ops/sec [92,482..94,528] → 95,786 ops/sec [89,523..112,879]	~ overlap (+1.8%)
with defaults	67,334 ops/sec [66,012..68,765] → 66,299 ops/sec [66,071..66,353]	~ overlap (-1.5%)	129,371 ops/sec [128,680..129,628] → 127,688 ops/sec [127,267..139,758]	~ overlap (-1.3%)
with renaming	70,890 ops/sec [69,351..71,867] → 71,971 ops/sec [69,565..74,035]	~ overlap (+1.5%)	99,126 ops/sec [95,492..109,111] → 99,852 ops/sec [98,140..107,546]	~ overlap (+0.7%)
nested object destructuring	40,952 ops/sec [40,706..41,705] → 42,682 ops/sec [40,354..57,491]	~ overlap (+4.2%)	51,203 ops/sec [49,353..52,688] → 51,763 ops/sec [49,037..55,382]	~ overlap (+1.1%)
rest properties	36,474 ops/sec [35,577..36,894] → 36,142 ops/sec [35,784..36,895]	~ overlap (-0.9%)	44,949 ops/sec [40,855..49,851] → 40,183 ops/sec [39,850..40,399]	🔴 -10.6%
object parameter	21,513 ops/sec [21,420..21,615] → 21,738 ops/sec [21,263..24,896]	~ overlap (+1.0%)	43,657 ops/sec [43,033..44,847] → 44,096 ops/sec [43,251..44,746]	~ overlap (+1.0%)
array parameter	25,189 ops/sec [24,185..28,820] → 25,278 ops/sec [24,535..33,290]	~ overlap (+0.4%)	40,653 ops/sec [37,473..44,774] → 40,368 ops/sec [39,835..46,464]	~ overlap (-0.7%)
mixed destructuring in map	6,012 ops/sec [5,902..6,075] → 6,198 ops/sec [5,671..7,136]	~ overlap (+3.1%)	9,331 ops/sec [9,139..9,436] → 9,078 ops/sec [8,936..9,841]	~ overlap (-2.7%)
forEach with array destructuring	11,373 ops/sec [11,210..11,416] → 11,508 ops/sec [11,138..11,865]	~ overlap (+1.2%)	14,227 ops/sec [13,977..15,422] → 14,112 ops/sec [12,458..15,534]	~ overlap (-0.8%)
map with array destructuring	12,157 ops/sec [12,067..12,192] → 12,405 ops/sec [12,380..12,426]	🟢 +2.0%	12,664 ops/sec [12,494..12,698] → 11,863 ops/sec [11,211..12,922]	~ overlap (-6.3%)
filter with array destructuring	12,865 ops/sec [12,777..12,940] → 13,136 ops/sec [13,062..13,167]	🟢 +2.1%	13,317 ops/sec [13,212..13,976] → 13,449 ops/sec [13,252..13,763]	~ overlap (+1.0%)
reduce with array destructuring	14,091 ops/sec [13,998..14,172] → 15,149 ops/sec [13,972..16,512]	~ overlap (+7.5%)	14,399 ops/sec [14,023..14,686] → 14,744 ops/sec [14,709..14,926]	🟢 +2.4%
map with object destructuring	13,781 ops/sec [13,435..13,974] → 13,981 ops/sec [13,854..14,441]	~ overlap (+1.4%)	16,675 ops/sec [16,576..17,035] → 17,368 ops/sec [17,267..17,572]	🟢 +4.2%
map with nested destructuring	11,126 ops/sec [10,878..11,894] → 11,287 ops/sec [10,950..12,619]	~ overlap (+1.4%)	16,998 ops/sec [16,862..19,103] → 17,555 ops/sec [16,838..17,798]	~ overlap (+3.3%)
map with rest in destructuring	6,532 ops/sec [6,472..6,597] → 6,625 ops/sec [6,345..6,760]	~ overlap (+1.4%)	6,475 ops/sec [6,405..6,607] → 6,676 ops/sec [6,557..6,828]	~ overlap (+3.1%)
map with defaults in destructuring	7,878 ops/sec [7,614..8,380] → 8,197 ops/sec [7,871..10,785]	~ overlap (+4.0%)	15,187 ops/sec [14,033..15,741] → 14,942 ops/sec [14,876..14,973]	~ overlap (-1.6%)

fibonacci.js — Interp: 🔴 1, 7 unch. · avg +1.1% · Bytecode: 🔴 1, 7 unch. · avg -0.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
recursive fib(15)	81 ops/sec [80..115] → 82 ops/sec [81..116]	~ overlap (+0.7%)	1,455 ops/sec [1,447..1,726] → 1,459 ops/sec [1,438..1,466]	~ overlap (+0.3%)
recursive fib(20)	8 ops/sec [8..8] → 8 ops/sec [7..8]	~ overlap (-0.8%)	137 ops/sec [132..145] → 133 ops/sec [131..181]	~ overlap (-3.0%)
recursive fib(15) typed	82 ops/sec [80..113] → 81 ops/sec [81..82]	~ overlap (-0.8%)	1,362 ops/sec [1,347..1,364] → 1,365 ops/sec [1,343..1,914]	~ overlap (+0.2%)
recursive fib(20) typed	8 ops/sec [7..8] → 8 ops/sec [8..8]	~ overlap (+1.1%)	127 ops/sec [123..130] → 136 ops/sec [116..137]	~ overlap (+6.5%)
iterative fib(20) via reduce	3,889 ops/sec [3,716..4,690] → 4,400 ops/sec [3,937..4,698]	~ overlap (+13.1%)	5,212 ops/sec [4,964..5,969] → 5,026 ops/sec [4,935..5,395]	~ overlap (-3.6%)
iterator fib(20)	2,021 ops/sec [2,009..2,136] → 1,970 ops/sec [1,956..1,988]	🔴 -2.5%	4,595 ops/sec [4,567..5,248] → 4,402 ops/sec [4,319..4,447]	🔴 -4.2%
iterator fib(20) via Iterator.from + take	2,039 ops/sec [1,918..2,053] → 1,987 ops/sec [1,886..2,103]	~ overlap (-2.6%)	2,726 ops/sec [2,674..2,750] → 2,577 ops/sec [2,539..3,058]	~ overlap (-5.5%)
iterator fib(20) last value via reduce	1,670 ops/sec [1,657..1,682] → 1,683 ops/sec [1,673..1,845]	~ overlap (+0.7%)	2,156 ops/sec [2,121..2,258] → 2,208 ops/sec [2,041..2,366]	~ overlap (+2.4%)

float16array.js — Interp: 🟢 3, 🔴 4, 25 unch. · avg -0.4% · Bytecode: 🟢 2, 🔴 2, 28 unch. · avg +1.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
new Float16Array(0)	102,480 ops/sec [101,672..103,098] → 103,700 ops/sec [102,777..104,670]	~ overlap (+1.2%)	127,100 ops/sec [125,568..132,139] → 130,020 ops/sec [114,176..145,022]	~ overlap (+2.3%)
new Float16Array(100)	99,701 ops/sec [98,226..131,335] → 100,218 ops/sec [99,906..100,914]	~ overlap (+0.5%)	122,125 ops/sec [120,292..123,554] → 122,613 ops/sec [117,907..141,416]	~ overlap (+0.4%)
new Float16Array(1000)	86,835 ops/sec [86,491..88,690] → 89,161 ops/sec [87,473..89,596]	~ overlap (+2.7%)	103,773 ops/sec [103,648..104,381] → 101,872 ops/sec [100,244..103,534]	🔴 -1.8%
Float16Array.from([...100])	1,219 ops/sec [1,213..1,281] → 1,264 ops/sec [1,245..1,346]	~ overlap (+3.7%)	1,235 ops/sec [1,206..1,254] → 1,302 ops/sec [1,258..1,452]	🟢 +5.4%
Float16Array.of(1.5, 2.5, 3.5, 4.5, 5.5)	64,644 ops/sec [64,484..64,893] → 64,219 ops/sec [62,945..67,108]	~ overlap (-0.7%)	71,177 ops/sec [68,748..73,848] → 82,006 ops/sec [73,453..93,389]	~ overlap (+15.2%)
new Float16Array(float64Array)	25,697 ops/sec [25,096..25,898] → 25,745 ops/sec [25,356..25,917]	~ overlap (+0.2%)	27,754 ops/sec [27,208..34,156] → 27,550 ops/sec [26,478..28,031]	~ overlap (-0.7%)
sequential write 100 elements	899 ops/sec [895..902] → 913 ops/sec [900..1,116]	~ overlap (+1.6%)	5,971 ops/sec [5,668..6,359] → 5,928 ops/sec [5,672..6,732]	~ overlap (-0.7%)
sequential read 100 elements	1,069 ops/sec [1,007..1,105] → 1,036 ops/sec [1,031..1,040]	~ overlap (-3.0%)	7,493 ops/sec [7,036..8,400] → 7,427 ops/sec [7,391..7,626]	~ overlap (-0.9%)
write special values (NaN, Inf, -0)	44,341 ops/sec [43,211..44,434] → 44,867 ops/sec [44,721..44,929]	🟢 +1.2%	177,958 ops/sec [174,121..258,245] → 177,777 ops/sec [176,589..194,072]	~ overlap (-0.1%)
Float16Array write	894 ops/sec [883..897] → 905 ops/sec [900..906]	🟢 +1.3%	5,821 ops/sec [5,705..6,023] → 5,901 ops/sec [5,874..5,912]	~ overlap (+1.4%)
Float32Array write	901 ops/sec [871..929] → 906 ops/sec [897..910]	~ overlap (+0.5%)	5,795 ops/sec [5,626..6,059] → 5,876 ops/sec [5,678..6,769]	~ overlap (+1.4%)
Float64Array write	995 ops/sec [895..1,005] → 909 ops/sec [904..913]	~ overlap (-8.6%)	5,889 ops/sec [5,721..6,363] → 5,684 ops/sec [5,600..5,750]	~ overlap (-3.5%)
Float16Array read	1,053 ops/sec [1,045..1,099] → 1,027 ops/sec [1,014..1,030]	🔴 -2.5%	7,410 ops/sec [7,194..7,820] → 7,409 ops/sec [7,269..8,011]	~ overlap (-0.0%)
Float32Array read	1,061 ops/sec [1,055..1,070] → 1,024 ops/sec [1,019..1,029]	🔴 -3.5%	7,428 ops/sec [7,216..7,505] → 6,703 ops/sec [6,616..7,489]	~ overlap (-9.8%)
Float64Array read	1,059 ops/sec [1,006..1,082] → 1,065 ops/sec [1,053..1,072]	~ overlap (+0.6%)	7,417 ops/sec [7,091..7,633] → 7,298 ops/sec [6,618..7,372]	~ overlap (-1.6%)
fill(1.5)	7,119 ops/sec [6,636..7,658] → 6,889 ops/sec [6,820..7,235]	~ overlap (-3.2%)	6,857 ops/sec [6,711..7,292] → 6,643 ops/sec [6,573..6,658]	🔴 -3.1%
slice()	53,645 ops/sec [53,339..53,803] → 55,384 ops/sec [50,055..58,107]	~ overlap (+3.2%)	55,106 ops/sec [51,525..62,373] → 58,978 ops/sec [57,492..64,732]	~ overlap (+7.0%)
map(x => x * 2)	1,946 ops/sec [1,743..2,019] → 1,970 ops/sec [1,918..1,983]	~ overlap (+1.2%)	1,813 ops/sec [1,800..1,817] → 1,865 ops/sec [1,828..1,912]	🟢 +2.8%
filter(x => x > 25)	2,010 ops/sec [1,754..3,297] → 2,017 ops/sec [1,981..2,113]	~ overlap (+0.3%)	2,011 ops/sec [1,879..2,142] → 2,055 ops/sec [2,045..2,082]	~ overlap (+2.2%)
reduce (sum)	1,707 ops/sec [1,658..1,767] → 1,866 ops/sec [1,810..1,888]	🟢 +9.3%	1,802 ops/sec [1,785..1,876] → 1,863 ops/sec [1,858..1,864]	~ overlap (+3.4%)
sort()	21,827 ops/sec [20,657..26,854] → 22,778 ops/sec [21,518..23,619]	~ overlap (+4.4%)	22,971 ops/sec [22,807..23,140] → 23,029 ops/sec [22,900..23,356]	~ overlap (+0.3%)
indexOf()	26,846 ops/sec [25,779..28,149] → 27,036 ops/sec [26,415..34,275]	~ overlap (+0.7%)	28,246 ops/sec [27,130..32,618] → 30,371 ops/sec [28,571..33,876]	~ overlap (+7.5%)
reverse()	28,876 ops/sec [28,303..32,223] → 26,669 ops/sec [26,435..28,201]	🔴 -7.6%	30,088 ops/sec [29,202..30,396] → 31,294 ops/sec [29,873..36,806]	~ overlap (+4.0%)
toReversed()	25,982 ops/sec [25,777..26,213] → 25,700 ops/sec [23,612..28,150]	~ overlap (-1.1%)	27,884 ops/sec [27,460..28,139] → 27,551 ops/sec [27,455..27,850]	~ overlap (-1.2%)
toSorted()	13,348 ops/sec [13,185..13,509] → 13,631 ops/sec [13,285..14,656]	~ overlap (+2.1%)	13,666 ops/sec [13,478..15,652] → 13,881 ops/sec [13,745..14,017]	~ overlap (+1.6%)
create view over existing buffer	123,931 ops/sec [120,524..143,823] → 125,566 ops/sec [122,683..127,482]	~ overlap (+1.3%)	165,034 ops/sec [160,692..166,251] → 164,531 ops/sec [159,903..166,687]	~ overlap (-0.3%)
subarray()	60,448 ops/sec [57,435..62,621] → 55,008 ops/sec [54,538..55,932]	🔴 -9.0%	68,051 ops/sec [66,986..72,765] → 69,291 ops/sec [67,576..69,577]	~ overlap (+1.8%)
set() from array	65,028 ops/sec [63,477..70,525] → 62,962 ops/sec [62,390..64,594]	~ overlap (-3.2%)	76,817 ops/sec [74,969..86,824] → 76,897 ops/sec [74,765..76,968]	~ overlap (+0.1%)
for-of loop	1,388 ops/sec [1,327..1,424] → 1,322 ops/sec [1,263..1,494]	~ overlap (-4.8%)	8,652 ops/sec [8,573..8,801] → 9,121 ops/sec [8,630..11,463]	~ overlap (+5.4%)
spread into array	5,951 ops/sec [5,365..6,548] → 5,736 ops/sec [5,525..7,769]	~ overlap (-3.6%)	18,442 ops/sec [18,402..18,966] → 19,005 ops/sec [18,386..22,154]	~ overlap (+3.0%)
f16round(1.337)	135,920 ops/sec [134,973..140,460] → 137,292 ops/sec [135,605..159,814]	~ overlap (+1.0%)	204,452 ops/sec [194,240..258,528] → 200,243 ops/sec [194,409..203,274]	~ overlap (-2.1%)
f16round over 100 values	884 ops/sec [840..970] → 880 ops/sec [874..894]	~ overlap (-0.4%)	2,589 ops/sec [2,453..2,601] → 2,588 ops/sec [2,535..2,877]	~ overlap (-0.0%)

for-in/for-in.js — Interp: 🟢 1, 2 unch. · avg +2.6% · Bytecode: 3 unch. · avg +3.3%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for...in over 50 own keys	2,419 ops/sec [2,404..2,420] → 2,520 ops/sec [2,465..2,663]	🟢 +4.1%	3,437 ops/sec [3,232..3,571] → 3,490 ops/sec [3,423..3,504]	~ overlap (+1.6%)
for...in over an 8-level chain of 50 shared keys	1,659 ops/sec [1,597..2,007] → 1,714 ops/sec [1,676..1,900]	~ overlap (+3.3%)	2,218 ops/sec [2,214..2,230] → 2,459 ops/sec [2,176..3,316]	~ overlap (+10.9%)
for...in over a 16-level chain of 100 shared keys	615 ops/sec [603..619] → 616 ops/sec [602..633]	~ overlap (+0.2%)	809 ops/sec [776..912] → 788 ops/sec [755..795]	~ overlap (-2.6%)

for-of.js — Interp: 🟢 1, 6 unch. · avg +0.7% · Bytecode: 7 unch. · avg -1.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for...of with 10-element array	11,095 ops/sec [10,920..11,249] → 11,309 ops/sec [11,042..11,503]	~ overlap (+1.9%)	80,000 ops/sec [78,569..80,507] → 76,779 ops/sec [75,777..80,976]	~ overlap (-4.0%)
for...of with 100-element array	1,320 ops/sec [1,224..1,484] → 1,312 ops/sec [1,283..1,443]	~ overlap (-0.6%)	11,826 ops/sec [11,121..12,359] → 11,765 ops/sec [11,668..11,840]	~ overlap (-0.5%)
for...of with string (10 chars)	8,173 ops/sec [7,991..8,193] → 8,193 ops/sec [8,017..8,350]	~ overlap (+0.2%)	19,793 ops/sec [19,617..20,033] → 20,015 ops/sec [19,689..22,031]	~ overlap (+1.1%)
for...of with Set (10 elements)	11,736 ops/sec [11,593..11,959] → 12,503 ops/sec [12,387..12,633]	🟢 +6.5%	114,065 ops/sec [113,058..115,069] → 112,982 ops/sec [112,462..116,886]	~ overlap (-0.9%)
for...of with Map entries (10 entries)	6,130 ops/sec [5,976..6,525] → 6,086 ops/sec [5,231..7,434]	~ overlap (-0.7%)	11,516 ops/sec [11,089..12,614] → 11,717 ops/sec [11,534..13,967]	~ overlap (+1.7%)
for...of with destructuring	6,587 ops/sec [6,574..6,598] → 6,595 ops/sec [6,535..6,617]	~ overlap (+0.1%)	13,942 ops/sec [13,626..13,961] → 13,589 ops/sec [13,531..13,647]	~ overlap (-2.5%)
for-await-of with sync array	7,463 ops/sec [7,416..7,488] → 7,287 ops/sec [7,272..7,770]	~ overlap (-2.4%)	1,954 ops/sec [1,810..2,137] → 1,893 ops/sec [1,871..1,911]	~ overlap (-3.1%)

generators.js — Interp: 🔴 1, 3 unch. · avg -6.3% · Bytecode: 🟢 1, 3 unch. · avg +3.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
manual next over object generator	578 ops/sec [569..633] → 560 ops/sec [553..574]	~ overlap (-3.2%)	913 ops/sec [911..918] → 1,022 ops/sec [924..1,063]	🟢 +12.0%
for...of over object generator	862 ops/sec [830..867] → 859 ops/sec [822..869]	~ overlap (-0.4%)	1,333 ops/sec [1,321..1,345] → 1,352 ops/sec [1,324..1,415]	~ overlap (+1.4%)
yield delegation	864 ops/sec [838..869] → 760 ops/sec [747..772]	🔴 -12.0%	1,322 ops/sec [1,302..1,419] → 1,279 ops/sec [1,258..1,309]	~ overlap (-3.2%)
class generator method	847 ops/sec [820..879] → 767 ops/sec [765..865]	~ overlap (-9.4%)	1,336 ops/sec [1,303..1,555] → 1,361 ops/sec [1,322..1,484]	~ overlap (+1.9%)

intl.js — Interp: 🟢 1, 🔴 1, 4 unch. · avg -1.8% · Bytecode: 🟢 1, 5 unch. · avg +1.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
format decimal	22,504 ops/sec [22,067..22,649] → 23,393 ops/sec [23,201..24,388]	🟢 +3.9%	24,074 ops/sec [22,841..24,446] → 24,774 ops/sec [22,969..27,706]	~ overlap (+2.9%)
format currency	18,160 ops/sec [17,852..19,750] → 16,468 ops/sec [16,167..16,839]	🔴 -9.3%	19,382 ops/sec [19,124..19,606] → 19,232 ops/sec [18,156..19,799]	~ overlap (-0.8%)
format UTC date	8,741 ops/sec [8,435..9,857] → 8,577 ops/sec [8,510..8,821]	~ overlap (-1.9%)	8,643 ops/sec [8,471..8,683] → 9,076 ops/sec [8,963..9,097]	🟢 +5.0%
formatRange UTC dates	2,706 ops/sec [2,674..3,133] → 2,649 ops/sec [2,573..2,750]	~ overlap (-2.1%)	2,761 ops/sec [2,695..2,894] → 2,792 ops/sec [2,571..2,852]	~ overlap (+1.1%)
compare numeric strings	85,698 ops/sec [85,203..86,087] → 85,452 ops/sec [85,135..91,533]	~ overlap (-0.3%)	104,600 ops/sec [104,190..104,963] → 104,342 ops/sec [104,133..104,660]	~ overlap (-0.2%)
sort short string list	14,801 ops/sec [14,456..14,937] → 14,636 ops/sec [14,310..14,831]	~ overlap (-1.1%)	16,047 ops/sec [15,827..16,076] → 15,883 ops/sec [15,728..17,693]	~ overlap (-1.0%)

iterators.js — Interp: 🟢 4, 🔴 2, 36 unch. · avg +0.2% · Bytecode: 🟢 1, 🔴 7, 34 unch. · avg -1.8%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Iterator.from({next}).toArray() — 20 elements	2,989 ops/sec [2,869..3,004] → 3,008 ops/sec [2,964..3,031]	~ overlap (+0.6%)	4,574 ops/sec [4,502..4,665] → 4,599 ops/sec [4,442..4,823]	~ overlap (+0.6%)
Iterator.from({next}).toArray() — 50 elements	1,287 ops/sec [1,285..1,290] → 1,302 ops/sec [1,285..1,328]	~ overlap (+1.2%)	2,004 ops/sec [1,984..2,126] → 1,982 ops/sec [1,917..2,120]	~ overlap (-1.1%)
spread pre-wrapped iterator — 20 elements	2,678 ops/sec [2,495..2,701] → 2,743 ops/sec [2,479..2,848]	~ overlap (+2.4%)	4,904 ops/sec [4,897..4,918] → 4,970 ops/sec [4,841..4,987]	~ overlap (+1.3%)
Iterator.from({next}).forEach — 50 elements	912 ops/sec [905..921] → 871 ops/sec [859..932]	~ overlap (-4.5%)	1,407 ops/sec [1,398..1,410] → 1,369 ops/sec [1,353..1,378]	🔴 -2.7%
Iterator.from({next}).reduce — 50 elements	986 ops/sec [983..993] → 966 ops/sec [952..968]	🔴 -2.1%	1,384 ops/sec [1,377..1,409] → 1,351 ops/sec [1,343..1,370]	🔴 -2.4%
wrap array iterator	13,245 ops/sec [12,575..13,948] → 13,035 ops/sec [12,484..13,076]	~ overlap (-1.6%)	14,372 ops/sec [14,258..14,432] → 14,028 ops/sec [13,805..14,284]	~ overlap (-2.4%)
wrap plain {next()} object	2,017 ops/sec [1,968..2,065] → 2,061 ops/sec [1,989..2,120]	~ overlap (+2.2%)	3,273 ops/sec [3,162..3,282] → 3,210 ops/sec [3,194..3,217]	~ overlap (-1.9%)
map + toArray (50 elements)	702 ops/sec [692..718] → 662 ops/sec [653..732]	~ overlap (-5.6%)	896 ops/sec [874..906] → 900 ops/sec [883..995]	~ overlap (+0.4%)
filter + toArray (50 elements)	781 ops/sec [711..852] → 742 ops/sec [724..753]	~ overlap (-4.9%)	990 ops/sec [975..1,022] → 1,007 ops/sec [1,003..1,016]	~ overlap (+1.7%)
take(10) + toArray (50 element source)	3,768 ops/sec [3,640..4,242] → 3,685 ops/sec [3,648..3,771]	~ overlap (-2.2%)	5,021 ops/sec [4,822..5,320] → 5,024 ops/sec [4,964..5,113]	~ overlap (+0.1%)
drop(40) + toArray (50 element source)	1,056 ops/sec [981..1,154] → 1,002 ops/sec [998..1,018]	~ overlap (-5.1%)	1,442 ops/sec [1,397..2,076] → 1,484 ops/sec [1,464..1,585]	~ overlap (+2.9%)
chained map + filter + take (100 element source)	1,065 ops/sec [1,063..1,069] → 1,099 ops/sec [1,080..1,114]	🟢 +3.2%	1,306 ops/sec [1,280..1,462] → 1,362 ops/sec [1,320..1,374]	~ overlap (+4.3%)
some + every (50 elements)	530 ops/sec [515..538] → 529 ops/sec [520..538]	~ overlap (-0.3%)	783 ops/sec [766..793] → 747 ops/sec [735..754]	🔴 -4.6%
find (50 elements)	1,223 ops/sec [1,166..1,375] → 1,188 ops/sec [1,163..1,316]	~ overlap (-2.9%)	1,708 ops/sec [1,699..1,717] → 1,677 ops/sec [1,629..1,809]	~ overlap (-1.8%)
concat 2 arrays (10 + 10 elements)	5,277 ops/sec [4,998..6,111] → 5,242 ops/sec [5,053..5,847]	~ overlap (-0.7%)	5,319 ops/sec [5,292..5,352] → 5,380 ops/sec [5,301..5,562]	~ overlap (+1.1%)
concat 5 arrays (10 elements each)	2,184 ops/sec [2,141..2,305] → 2,196 ops/sec [2,180..2,281]	~ overlap (+0.5%)	2,300 ops/sec [2,279..2,807] → 2,264 ops/sec [2,234..2,335]	~ overlap (-1.6%)
concat 2 arrays (20 + 20 elements)	2,792 ops/sec [2,703..2,926] → 2,819 ops/sec [2,813..2,913]	~ overlap (+1.0%)	2,948 ops/sec [2,701..3,310] → 2,930 ops/sec [2,862..3,732]	~ overlap (-0.6%)
concat + filter + toArray (20 + 20 elements)	1,241 ops/sec [1,223..1,246] → 1,259 ops/sec [1,239..1,370]	~ overlap (+1.4%)	1,403 ops/sec [1,369..1,431] → 1,426 ops/sec [1,310..1,561]	~ overlap (+1.7%)
concat + map + take (20 + 20 elements, take 10)	2,962 ops/sec [2,921..3,366] → 3,098 ops/sec [3,019..3,125]	~ overlap (+4.6%)	3,153 ops/sec [3,145..3,316] → 3,157 ops/sec [3,117..3,411]	~ overlap (+0.1%)
concat Sets (15 + 15 elements)	3,788 ops/sec [3,775..3,854] → 3,900 ops/sec [3,812..3,950]	~ overlap (+2.9%)	3,934 ops/sec [3,897..4,259] → 3,926 ops/sec [3,897..4,043]	~ overlap (-0.2%)
concat boxed strings (13 + 13 characters)	3,976 ops/sec [3,878..4,007] → 3,991 ops/sec [3,899..4,034]	~ overlap (+0.4%)	4,039 ops/sec [3,982..4,201] → 4,026 ops/sec [3,829..4,729]	~ overlap (-0.3%)
zip 2 arrays (10 + 10 elements)	9,268 ops/sec [9,015..9,759] → 9,096 ops/sec [8,698..9,855]	~ overlap (-1.9%)	9,472 ops/sec [9,419..9,521] → 9,340 ops/sec [9,058..9,580]	~ overlap (-1.4%)
zip 3 arrays (10 elements each)	8,469 ops/sec [8,215..9,434] → 8,705 ops/sec [8,622..11,480]	~ overlap (+2.8%)	9,252 ops/sec [9,104..9,329] → 8,970 ops/sec [8,484..9,287]	~ overlap (-3.0%)
zip 2 arrays (20 + 20 elements)	5,400 ops/sec [5,186..5,412] → 5,531 ops/sec [5,434..6,634]	🟢 +2.4%	5,868 ops/sec [5,774..5,956] → 5,438 ops/sec [5,402..6,329]	~ overlap (-7.3%)
zip 2 arrays (50 + 50 elements)	2,503 ops/sec [2,443..3,428] → 2,618 ops/sec [2,439..3,021]	~ overlap (+4.6%)	2,620 ops/sec [2,595..2,914] → 2,409 ops/sec [2,393..2,428]	🔴 -8.0%
zip shortest mode (20 + 10 elements)	9,160 ops/sec [8,915..9,686] → 9,641 ops/sec [9,086..10,742]	~ overlap (+5.3%)	9,703 ops/sec [9,607..13,390] → 8,835 ops/sec [8,763..10,424]	~ overlap (-8.9%)
zip longest mode (10 + 20 elements)	5,704 ops/sec [5,306..5,770] → 5,182 ops/sec [5,143..5,391]	~ overlap (-9.2%)	5,617 ops/sec [5,391..6,213] → 5,387 ops/sec [5,332..5,438]	~ overlap (-4.1%)
zip strict mode (20 + 20 elements)	5,581 ops/sec [5,397..6,163] → 5,329 ops/sec [5,142..6,148]	~ overlap (-4.5%)	6,001 ops/sec [5,522..7,838] → 5,382 ops/sec [5,271..5,973]	~ overlap (-10.3%)
zip + map + toArray (20 + 20 elements)	2,031 ops/sec [1,914..2,190] → 1,868 ops/sec [1,768..1,893]	🔴 -8.0%	2,002 ops/sec [1,797..2,154] → 1,748 ops/sec [1,726..1,760]	🔴 -12.7%
zip + filter + toArray (20 + 20 elements)	1,930 ops/sec [1,910..1,962] → 2,008 ops/sec [1,972..2,027]	🟢 +4.0%	2,054 ops/sec [1,985..2,135] → 1,986 ops/sec [1,861..2,139]	~ overlap (-3.3%)
zip Sets (15 + 15 elements)	7,450 ops/sec [7,316..10,302] → 7,722 ops/sec [7,387..7,742]	~ overlap (+3.7%)	8,009 ops/sec [7,865..8,239] → 7,709 ops/sec [7,338..8,182]	~ overlap (-3.7%)
zipKeyed 2 keys (10 elements each)	8,795 ops/sec [8,601..9,031] → 9,163 ops/sec [8,662..11,280]	~ overlap (+4.2%)	9,664 ops/sec [9,009..11,390] → 9,021 ops/sec [8,797..9,301]	~ overlap (-6.7%)
zipKeyed 3 keys (20 elements each)	4,607 ops/sec [4,534..4,680] → 4,679 ops/sec [4,566..5,294]	~ overlap (+1.6%)	4,690 ops/sec [4,483..4,853] → 4,537 ops/sec [4,524..4,575]	~ overlap (-3.3%)
zipKeyed longest mode (10 + 20 elements)	5,066 ops/sec [4,910..5,463] → 4,941 ops/sec [4,929..6,480]	~ overlap (-2.5%)	5,348 ops/sec [5,219..5,493] → 5,227 ops/sec [5,124..6,212]	~ overlap (-2.3%)
zipKeyed strict mode (20 + 20 elements)	5,132 ops/sec [4,877..6,021] → 5,004 ops/sec [4,930..5,165]	~ overlap (-2.5%)	5,028 ops/sec [4,931..5,160] → 5,310 ops/sec [5,178..5,373]	🟢 +5.6%
zipKeyed + filter + map (20 elements)	1,651 ops/sec [1,615..1,764] → 1,678 ops/sec [1,622..1,694]	~ overlap (+1.6%)	1,930 ops/sec [1,917..1,956] → 1,870 ops/sec [1,856..1,892]	🔴 -3.1%
array.values().map().filter().toArray()	684 ops/sec [682..691] → 688 ops/sec [684..711]	~ overlap (+0.5%)	736 ops/sec [732..740] → 717 ops/sec [706..722]	🔴 -2.6%
array.values().take(5).toArray()	11,137 ops/sec [11,001..11,274] → 11,452 ops/sec [10,949..12,549]	~ overlap (+2.8%)	12,276 ops/sec [11,921..16,572] → 12,177 ops/sec [11,777..13,541]	~ overlap (-0.8%)
array.values().drop(45).toArray()	2,316 ops/sec [2,287..2,345] → 2,403 ops/sec [2,285..2,443]	~ overlap (+3.8%)	2,463 ops/sec [2,442..2,468] → 2,515 ops/sec [2,330..2,559]	~ overlap (+2.1%)
map.entries() chained helpers	935 ops/sec [906..959] → 987 ops/sec [953..993]	~ overlap (+5.6%)	966 ops/sec [946..976] → 928 ops/sec [912..951]	~ overlap (-3.9%)
set.values() chained helpers	1,638 ops/sec [1,578..1,645] → 1,712 ops/sec [1,692..1,721]	🟢 +4.5%	1,808 ops/sec [1,759..1,838] → 1,788 ops/sec [1,776..2,001]	~ overlap (-1.1%)
string iterator map + toArray	1,715 ops/sec [1,593..1,866] → 1,718 ops/sec [1,644..2,115]	~ overlap (+0.2%)	1,676 ops/sec [1,645..2,059] → 1,785 ops/sec [1,696..2,016]	~ overlap (+6.5%)

json.js — Interp: 🔴 1, 22 unch. · avg +0.2% · Bytecode: 🟢 7, 🔴 1, 15 unch. · avg +2.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple object	35,910 ops/sec [34,968..36,960] → 36,607 ops/sec [36,398..38,375]	~ overlap (+1.9%)	39,878 ops/sec [39,505..39,926] → 40,965 ops/sec [40,673..41,056]	🟢 +2.7%
parse nested object	21,400 ops/sec [21,379..21,520] → 21,871 ops/sec [20,188..23,660]	~ overlap (+2.2%)	23,633 ops/sec [23,478..23,885] → 24,621 ops/sec [24,500..24,714]	🟢 +4.2%
parse array of objects	13,521 ops/sec [13,350..15,040] → 13,281 ops/sec [12,717..13,858]	~ overlap (-1.8%)	14,442 ops/sec [14,291..14,667] → 14,960 ops/sec [14,883..15,035]	🟢 +3.6%
parse large flat object	14,553 ops/sec [13,998..15,104] → 13,940 ops/sec [13,697..14,024]	~ overlap (-4.2%)	15,100 ops/sec [14,935..15,281] → 15,168 ops/sec [14,962..15,551]	~ overlap (+0.5%)
parse mixed types	12,499 ops/sec [12,413..12,735] → 12,414 ops/sec [12,193..12,673]	~ overlap (-0.7%)	12,911 ops/sec [12,661..13,000] → 13,051 ops/sec [12,987..13,854]	~ overlap (+1.1%)
stringify simple object	46,479 ops/sec [45,504..46,629] → 45,336 ops/sec [43,818..45,474]	🔴 -2.5%	47,166 ops/sec [46,759..47,765] → 47,576 ops/sec [47,487..47,592]	~ overlap (+0.9%)
stringify nested object	27,789 ops/sec [25,715..28,226] → 27,910 ops/sec [26,226..27,980]	~ overlap (+0.4%)	26,061 ops/sec [25,630..26,587] → 28,165 ops/sec [25,811..29,324]	~ overlap (+8.1%)
stringify array of objects	12,042 ops/sec [11,624..15,636] → 11,868 ops/sec [11,316..11,937]	~ overlap (-1.4%)	12,338 ops/sec [12,081..12,568] → 13,604 ops/sec [12,954..16,842]	🟢 +10.3%
stringify mixed types	23,064 ops/sec [22,907..24,715] → 24,342 ops/sec [22,595..26,990]	~ overlap (+5.5%)	23,024 ops/sec [22,122..24,850] → 23,455 ops/sec [22,248..25,904]	~ overlap (+1.9%)
reviver doubles numbers	8,012 ops/sec [7,940..8,153] → 7,812 ops/sec [7,736..8,108]	~ overlap (-2.5%)	10,496 ops/sec [10,271..10,605] → 10,718 ops/sec [10,395..10,983]	~ overlap (+2.1%)
reviver filters properties	7,798 ops/sec [7,705..8,003] → 7,973 ops/sec [7,638..8,219]	~ overlap (+2.2%)	9,580 ops/sec [9,399..9,614] → 9,484 ops/sec [9,298..9,715]	~ overlap (-1.0%)
reviver on nested object	9,133 ops/sec [9,037..9,427] → 9,208 ops/sec [8,929..10,096]	~ overlap (+0.8%)	11,358 ops/sec [10,906..12,007] → 11,277 ops/sec [11,154..11,789]	~ overlap (-0.7%)
reviver on array	4,990 ops/sec [4,872..5,139] → 5,087 ops/sec [4,867..5,471]	~ overlap (+2.0%)	6,703 ops/sec [6,592..8,797] → 6,487 ops/sec [6,397..6,500]	🔴 -3.2%
replacer function doubles numbers	10,301 ops/sec [10,232..10,330] → 10,300 ops/sec [10,069..10,590]	~ overlap (-0.0%)	14,031 ops/sec [13,622..14,120] → 14,213 ops/sec [13,699..14,483]	~ overlap (+1.3%)
replacer function excludes properties	13,462 ops/sec [13,180..13,650] → 13,689 ops/sec [13,265..14,660]	~ overlap (+1.7%)	17,629 ops/sec [16,628..17,891] → 18,116 ops/sec [17,236..19,079]	~ overlap (+2.8%)
array replacer (allowlist)	37,016 ops/sec [35,772..38,720] → 35,816 ops/sec [35,278..37,600]	~ overlap (-3.2%)	33,445 ops/sec [33,114..33,858] → 36,432 ops/sec [35,693..36,778]	🟢 +8.9%
stringify with 2-space indent	27,334 ops/sec [26,755..27,548] → 27,870 ops/sec [27,152..31,395]	~ overlap (+2.0%)	26,756 ops/sec [25,687..27,083] → 28,578 ops/sec [27,766..28,924]	🟢 +6.8%
stringify with tab indent	28,275 ops/sec [26,881..28,525] → 27,919 ops/sec [26,966..28,920]	~ overlap (-1.3%)	27,818 ops/sec [27,187..28,122] → 28,602 ops/sec [28,468..28,874]	🟢 +2.8%
stringify deeply nested object with 2-space indent	4,125 ops/sec [4,016..4,153] → 4,101 ops/sec [4,021..4,404]	~ overlap (-0.6%)	4,151 ops/sec [4,043..4,255] → 4,153 ops/sec [4,150..4,304]	~ overlap (+0.1%)
stringify deeply nested array with 2-space indent	5,860 ops/sec [5,731..6,040] → 5,985 ops/sec [5,904..6,198]	~ overlap (+2.1%)	6,076 ops/sec [6,004..6,615] → 6,096 ops/sec [6,090..6,130]	~ overlap (+0.3%)
stringify very deeply nested object with 2-space indent	666 ops/sec [647..679] → 693 ops/sec [673..795]	~ overlap (+4.1%)	716 ops/sec [678..735] → 684 ops/sec [647..701]	~ overlap (-4.4%)
parse then stringify	12,916 ops/sec [12,389..13,524] → 12,706 ops/sec [12,524..15,064]	~ overlap (-1.6%)	13,985 ops/sec [13,808..14,060] → 13,723 ops/sec [13,448..15,523]	~ overlap (-1.9%)
stringify then parse	7,630 ops/sec [7,561..7,996] → 7,591 ops/sec [7,344..7,998]	~ overlap (-0.5%)	8,288 ops/sec [8,244..8,343] → 8,560 ops/sec [7,742..11,056]	~ overlap (+3.3%)

jsx.jsx — Interp: 🟢 1, 🔴 1, 19 unch. · avg +2.0% · Bytecode: 🟢 2, 19 unch. · avg +1.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple element	69,091 ops/sec [68,121..69,645] → 65,589 ops/sec [61,509..67,835]	🔴 -5.1%	88,300 ops/sec [87,825..88,348] → 87,815 ops/sec [86,011..110,901]	~ overlap (-0.5%)
self-closing element	71,559 ops/sec [70,321..75,116] → 73,245 ops/sec [68,640..77,648]	~ overlap (+2.4%)	92,022 ops/sec [88,451..98,341] → 92,398 ops/sec [90,671..97,053]	~ overlap (+0.4%)
element with string attribute	66,920 ops/sec [59,659..79,308] → 61,372 ops/sec [59,769..61,667]	~ overlap (-8.3%)	67,028 ops/sec [61,335..75,331] → 69,127 ops/sec [67,981..71,391]	~ overlap (+3.1%)
element with multiple attributes	52,867 ops/sec [52,317..53,181] → 54,263 ops/sec [51,598..67,746]	~ overlap (+2.6%)	55,250 ops/sec [50,106..56,362] → 51,441 ops/sec [50,751..59,750]	~ overlap (-6.9%)
element with expression attribute	52,029 ops/sec [51,101..54,489] → 53,104 ops/sec [52,685..76,346]	~ overlap (+2.1%)	69,608 ops/sec [68,848..70,310] → 69,497 ops/sec [68,741..84,452]	~ overlap (-0.2%)
text child	69,914 ops/sec [69,457..71,616] → 72,960 ops/sec [70,329..79,140]	~ overlap (+4.4%)	88,770 ops/sec [88,100..95,433] → 91,720 ops/sec [89,244..93,949]	~ overlap (+3.3%)
expression child	62,502 ops/sec [61,810..66,568] → 63,911 ops/sec [63,274..71,149]	~ overlap (+2.3%)	84,240 ops/sec [80,064..88,138] → 85,647 ops/sec [84,929..92,860]	~ overlap (+1.7%)
mixed text and expression	59,959 ops/sec [58,624..62,707] → 61,691 ops/sec [61,277..86,891]	~ overlap (+2.9%)	77,783 ops/sec [77,407..78,373] → 81,301 ops/sec [78,344..100,491]	~ overlap (+4.5%)
nested elements (3 levels)	28,588 ops/sec [27,850..31,230] → 29,274 ops/sec [28,891..31,028]	~ overlap (+2.4%)	32,065 ops/sec [31,844..32,276] → 34,038 ops/sec [33,628..40,072]	🟢 +6.2%
sibling children	21,577 ops/sec [21,024..21,796] → 21,988 ops/sec [21,511..23,743]	~ overlap (+1.9%)	23,211 ops/sec [22,997..23,283] → 23,900 ops/sec [23,200..23,925]	~ overlap (+3.0%)
component element	49,475 ops/sec [48,267..50,600] → 51,480 ops/sec [50,598..52,895]	~ overlap (+4.1%)	59,798 ops/sec [59,058..73,937] → 64,981 ops/sec [61,424..73,903]	~ overlap (+8.7%)
component with children	32,066 ops/sec [30,842..32,199] → 37,640 ops/sec [32,355..47,436]	🟢 +17.4%	39,310 ops/sec [36,803..39,777] → 38,539 ops/sec [38,420..49,691]	~ overlap (-2.0%)
dotted component	47,239 ops/sec [42,449..51,506] → 43,283 ops/sec [42,595..47,226]	~ overlap (-8.4%)	50,473 ops/sec [49,958..51,613] → 54,728 ops/sec [50,990..63,785]	~ overlap (+8.4%)
empty fragment	70,390 ops/sec [69,586..71,691] → 70,866 ops/sec [70,056..71,765]	~ overlap (+0.7%)	114,017 ops/sec [92,573..120,170] → 95,954 ops/sec [95,544..96,188]	~ overlap (-15.8%)
fragment with children	21,299 ops/sec [20,750..21,638] → 21,448 ops/sec [21,179..26,261]	~ overlap (+0.7%)	28,786 ops/sec [24,994..30,866] → 26,174 ops/sec [25,724..27,073]	~ overlap (-9.1%)
spread attributes	33,285 ops/sec [32,687..33,460] → 33,305 ops/sec [32,751..35,890]	~ overlap (+0.1%)	35,541 ops/sec [34,972..36,318] → 34,844 ops/sec [34,275..35,435]	~ overlap (-2.0%)
spread with overrides	28,726 ops/sec [28,471..29,071] → 29,245 ops/sec [28,338..31,402]	~ overlap (+1.8%)	30,324 ops/sec [29,931..30,540] → 31,499 ops/sec [29,907..31,733]	~ overlap (+3.9%)
shorthand props	49,273 ops/sec [48,080..53,647] → 58,491 ops/sec [49,318..64,673]	~ overlap (+18.7%)	57,088 ops/sec [55,881..57,517] → 60,637 ops/sec [59,261..95,392]	🟢 +6.2%
nav bar structure	10,219 ops/sec [10,148..11,100] → 10,526 ops/sec [10,223..10,687]	~ overlap (+3.0%)	11,914 ops/sec [11,367..13,234] → 12,074 ops/sec [11,735..12,450]	~ overlap (+1.3%)
card component tree	12,283 ops/sec [12,179..12,316] → 12,148 ops/sec [11,893..13,829]	~ overlap (-1.1%)	13,214 ops/sec [12,967..15,278] → 13,729 ops/sec [13,004..15,500]	~ overlap (+3.9%)
10 list items via Array.from	5,065 ops/sec [4,981..5,671] → 4,939 ops/sec [4,919..5,351]	~ overlap (-2.5%)	4,818 ops/sec [4,698..4,957] → 4,979 ops/sec [4,398..6,484]	~ overlap (+3.3%)

modules.js — Interp: 🟢 1, 8 unch. · avg +1.7% · Bytecode: 9 unch. · avg -0.7%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
call imported function	108,558 ops/sec [105,714..128,279] → 108,413 ops/sec [106,467..113,207]	~ overlap (-0.1%)	35,327 ops/sec [33,310..36,064] → 37,275 ops/sec [33,913..43,658]	~ overlap (+5.5%)
call two imported functions	60,361 ops/sec [59,876..61,516] → 60,997 ops/sec [59,771..61,333]	~ overlap (+1.1%)	17,351 ops/sec [16,907..18,711] → 18,294 ops/sec [17,478..18,652]	~ overlap (+5.4%)
read imported constant	278,038 ops/sec [264,597..279,691] → 281,135 ops/sec [274,549..297,866]	~ overlap (+1.1%)	34,758 ops/sec [33,351..42,110] → 36,179 ops/sec [35,072..41,185]	~ overlap (+4.1%)
read imported string	268,911 ops/sec [261,158..273,569] → 276,942 ops/sec [275,353..294,679]	🟢 +3.0%	36,399 ops/sec [35,562..47,534] → 35,309 ops/sec [34,703..36,512]	~ overlap (-3.0%)
read JSON string property	270,546 ops/sec [264,418..275,552] → 275,207 ops/sec [273,129..279,413]	~ overlap (+1.7%)	36,881 ops/sec [35,229..39,566] → 35,808 ops/sec [35,386..44,041]	~ overlap (-2.9%)
read JSON number property	267,526 ops/sec [264,393..272,638] → 275,842 ops/sec [267,369..305,436]	~ overlap (+3.1%)	40,113 ops/sec [35,241..51,634] → 36,268 ops/sec [34,319..37,196]	~ overlap (-9.6%)
read JSON boolean property	277,154 ops/sec [263,408..290,870] → 284,722 ops/sec [272,374..352,567]	~ overlap (+2.7%)	36,237 ops/sec [35,452..36,486] → 36,418 ops/sec [35,141..36,592]	~ overlap (+0.5%)
read JSON array property	272,772 ops/sec [262,630..297,735] → 284,442 ops/sec [273,761..301,206]	~ overlap (+4.3%)	36,141 ops/sec [35,465..37,634] → 37,399 ops/sec [35,013..41,337]	~ overlap (+3.5%)
read multiple JSON properties	141,876 ops/sec [138,897..150,643] → 140,077 ops/sec [137,554..145,040]	~ overlap (-1.3%)	14,234 ops/sec [13,889..14,251] → 12,778 ops/sec [11,342..14,114]	~ overlap (-10.2%)

numbers.js — Interp: 12 unch. · avg -1.2% · Bytecode: 12 unch. · avg +0.8%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
integer arithmetic	66,932 ops/sec [64,341..70,557] → 67,639 ops/sec [64,077..72,132]	~ overlap (+1.1%)	364,592 ops/sec [361,325..403,756] → 373,433 ops/sec [368,995..402,679]	~ overlap (+2.4%)
floating point arithmetic	78,359 ops/sec [75,192..80,455] → 78,158 ops/sec [75,905..93,577]	~ overlap (-0.3%)	315,368 ops/sec [308,660..321,629] → 371,400 ops/sec [314,593..398,640]	~ overlap (+17.8%)
number coercion	15,842 ops/sec [15,456..18,965] → 15,579 ops/sec [11,440..15,931]	~ overlap (-1.7%)	20,727 ops/sec [18,868..25,741] → 19,429 ops/sec [19,258..20,838]	~ overlap (-6.3%)
toFixed	27,003 ops/sec [25,456..32,415] → 27,368 ops/sec [26,657..27,990]	~ overlap (+1.3%)	33,418 ops/sec [32,322..44,146] → 33,649 ops/sec [33,268..44,251]	~ overlap (+0.7%)
toString	42,361 ops/sec [40,549..48,792] → 42,611 ops/sec [40,816..43,917]	~ overlap (+0.6%)	58,898 ops/sec [57,490..61,016] → 58,686 ops/sec [49,930..60,865]	~ overlap (-0.4%)
toString non-integer (shortest round-trip)	8,737 ops/sec [8,505..9,853] → 8,971 ops/sec [8,563..9,218]	~ overlap (+2.7%)	15,283 ops/sec [15,250..15,342] → 15,588 ops/sec [14,905..16,212]	~ overlap (+2.0%)
valueOf	64,186 ops/sec [55,976..66,015] → 56,801 ops/sec [54,834..58,643]	~ overlap (-11.5%)	91,226 ops/sec [81,505..100,412] → 81,431 ops/sec [81,251..96,483]	~ overlap (-10.7%)
toPrecision	25,465 ops/sec [25,342..25,849] → 25,500 ops/sec [24,977..25,763]	~ overlap (+0.1%)	30,375 ops/sec [28,675..32,844] → 30,725 ops/sec [30,094..35,140]	~ overlap (+1.2%)
Number.isNaN	57,790 ops/sec [56,450..58,391] → 56,822 ops/sec [52,113..63,209]	~ overlap (-1.7%)	82,905 ops/sec [79,950..83,935] → 82,766 ops/sec [81,291..84,674]	~ overlap (-0.2%)
Number.isFinite	56,402 ops/sec [53,173..59,618] → 58,304 ops/sec [53,311..59,685]	~ overlap (+3.4%)	79,597 ops/sec [74,828..87,287] → 79,518 ops/sec [79,065..89,409]	~ overlap (-0.1%)
Number.isInteger	60,483 ops/sec [58,331..66,982] → 56,004 ops/sec [55,195..64,047]	~ overlap (-7.4%)	77,465 ops/sec [75,543..91,502] → 80,258 ops/sec [77,760..98,234]	~ overlap (+3.6%)
Number.parseInt and parseFloat	21,336 ops/sec [20,921..23,158] → 20,988 ops/sec [20,751..21,785]	~ overlap (-1.6%)	23,886 ops/sec [23,122..25,024] → 23,844 ops/sec [23,515..25,347]	~ overlap (-0.2%)

objects.js — Interp: 7 unch. · avg +0.5% · Bytecode: 7 unch. · avg -0.3%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
create simple object	132,215 ops/sec [128,648..133,548] → 132,150 ops/sec [131,703..133,146]	~ overlap (-0.0%)	126,263 ops/sec [120,367..138,716] → 129,155 ops/sec [120,284..156,638]	~ overlap (+2.3%)
create nested object	76,197 ops/sec [74,024..86,299] → 75,601 ops/sec [74,690..92,786]	~ overlap (-0.8%)	60,471 ops/sec [57,545..68,375] → 58,447 ops/sec [58,028..68,191]	~ overlap (-3.3%)
create 50 objects via Array.from	2,625 ops/sec [2,582..2,661] → 2,717 ops/sec [2,659..3,091]	~ overlap (+3.5%)	2,173 ops/sec [1,992..2,658] → 2,008 ops/sec [1,967..2,041]	~ overlap (-7.6%)
property read	99,808 ops/sec [98,386..101,426] → 98,753 ops/sec [98,300..102,826]	~ overlap (-1.1%)	316,506 ops/sec [307,656..345,079] → 327,686 ops/sec [307,308..374,328]	~ overlap (+3.5%)
Object.keys	66,558 ops/sec [62,061..77,434] → 64,352 ops/sec [64,002..75,426]	~ overlap (-3.3%)	75,323 ops/sec [72,034..82,451] → 77,346 ops/sec [74,101..87,189]	~ overlap (+2.7%)
Object.entries	34,495 ops/sec [34,282..34,534] → 37,113 ops/sec [34,135..49,706]	~ overlap (+7.6%)	37,399 ops/sec [36,927..38,124] → 37,529 ops/sec [37,257..43,112]	~ overlap (+0.3%)
spread operator	43,105 ops/sec [42,601..43,622] → 42,156 ops/sec [41,527..43,067]	~ overlap (-2.2%)	46,578 ops/sec [45,434..46,704] → 46,661 ops/sec [46,326..48,004]	~ overlap (+0.2%)

promises.js — Interp: 12 unch. · avg -0.1% · Bytecode: 🟢 2, 🔴 2, 8 unch. · avg +0.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Promise.resolve(value)	60,767 ops/sec [59,982..61,595] → 60,661 ops/sec [60,079..70,401]	~ overlap (-0.2%)	65,227 ops/sec [63,352..68,247] → 65,324 ops/sec [65,248..79,022]	~ overlap (+0.1%)
new Promise(resolve => resolve(value))	46,562 ops/sec [45,768..48,482] → 44,175 ops/sec [43,719..47,114]	~ overlap (-5.1%)	49,478 ops/sec [47,952..51,259] → 54,866 ops/sec [49,135..55,703]	~ overlap (+10.9%)
Promise.reject(reason)	62,283 ops/sec [60,098..66,154] → 63,127 ops/sec [62,996..63,232]	~ overlap (+1.4%)	64,972 ops/sec [63,950..65,870] → 66,302 ops/sec [65,173..91,652]	~ overlap (+2.0%)
resolve + then (1 handler)	20,445 ops/sec [19,562..20,525] → 20,544 ops/sec [20,202..20,723]	~ overlap (+0.5%)	21,942 ops/sec [21,775..22,196] → 22,817 ops/sec [22,676..23,060]	🟢 +4.0%
resolve + then chain (3 deep)	8,802 ops/sec [8,614..8,846] → 8,726 ops/sec [8,658..9,343]	~ overlap (-0.9%)	9,255 ops/sec [9,155..9,397] → 9,822 ops/sec [9,382..10,727]	~ overlap (+6.1%)
resolve + then chain (10 deep)	2,884 ops/sec [2,823..3,317] → 2,988 ops/sec [2,836..3,463]	~ overlap (+3.6%)	3,262 ops/sec [3,223..3,293] → 3,130 ops/sec [2,964..3,144]	🔴 -4.0%
reject + catch + then	13,406 ops/sec [12,159..15,500] → 13,298 ops/sec [12,050..15,517]	~ overlap (-0.8%)	12,793 ops/sec [11,909..13,132] → 12,353 ops/sec [12,271..12,450]	~ overlap (-3.4%)
resolve + finally + then	5,911 ops/sec [5,841..5,979] → 5,984 ops/sec [5,855..7,002]	~ overlap (+1.2%)	5,939 ops/sec [5,779..6,177] → 5,787 ops/sec [5,702..6,358]	~ overlap (-2.6%)
Promise.all (5 resolved)	4,178 ops/sec [3,830..4,363] → 4,259 ops/sec [3,873..4,495]	~ overlap (+1.9%)	3,972 ops/sec [3,941..4,115] → 3,843 ops/sec [3,831..3,885]	🔴 -3.2%
Promise.race (5 resolved)	4,740 ops/sec [4,253..5,902] → 4,604 ops/sec [4,418..4,654]	~ overlap (-2.9%)	4,584 ops/sec [4,563..4,598] → 4,442 ops/sec [4,419..4,681]	~ overlap (-3.1%)
Promise.allSettled (5 mixed)	3,600 ops/sec [3,520..3,951] → 3,575 ops/sec [3,286..3,791]	~ overlap (-0.7%)	3,376 ops/sec [3,321..3,403] → 3,499 ops/sec [3,456..5,246]	🟢 +3.7%
Promise.any (5 mixed)	4,127 ops/sec [3,854..4,364] → 4,163 ops/sec [3,990..4,474]	~ overlap (+0.9%)	4,140 ops/sec [3,961..4,358] → 4,151 ops/sec [4,100..4,251]	~ overlap (+0.3%)

property-access.js — Interp: 5 unch. · avg -2.0% · Bytecode: 5 unch. · avg -0.3%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
class instance fields across 1000 instances	114 ops/sec [111..122] → 117 ops/sec [113..117]	~ overlap (+2.7%)	822 ops/sec [805..843] → 822 ops/sec [816..825]	~ overlap (+0.0%)
object literal fields across 1000 literals	116 ops/sec [114..118] → 117 ops/sec [114..118]	~ overlap (+1.0%)	813 ops/sec [783..827] → 804 ops/sec [786..814]	~ overlap (-1.2%)
mixed-shape literals across 1000 literals	123 ops/sec [110..132] → 115 ops/sec [113..119]	~ overlap (-6.0%)	609 ops/sec [587..638] → 619 ops/sec [593..635]	~ overlap (+1.5%)
own-class method across 1000 instances	76 ops/sec [72..87] → 73 ops/sec [72..78]	~ overlap (-3.6%)	374 ops/sec [363..390] → 369 ops/sec [355..491]	~ overlap (-1.4%)
inherited method across 1000 instances	83 ops/sec [81..85] → 79 ops/sec [74..83]	~ overlap (-4.2%)	403 ops/sec [402..405] → 401 ops/sec [393..404]	~ overlap (-0.6%)

regexp.js — Interp: 13 unch. · avg +0.0% · Bytecode: 🟢 2, 11 unch. · avg +0.8%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
regex literal creation	7,874 ops/sec [7,699..8,045] → 7,894 ops/sec [7,566..8,371]	~ overlap (+0.3%)	204,809 ops/sec [201,374..211,195] → 213,141 ops/sec [204,653..223,504]	~ overlap (+4.1%)
new RegExp(pattern, flags)	7,620 ops/sec [7,423..9,305] → 7,999 ops/sec [7,340..8,848]	~ overlap (+5.0%)	7,657 ops/sec [7,625..7,705] → 7,772 ops/sec [7,739..7,904]	🟢 +1.5%
RegExp(existingRegex) returns the same regex	137,151 ops/sec [135,770..139,183] → 135,440 ops/sec [132,600..177,024]	~ overlap (-1.2%)	211,610 ops/sec [211,332..211,861] → 215,286 ops/sec [212,876..220,810]	🟢 +1.7%
test() on a global regex	64,515 ops/sec [61,114..73,515] → 62,534 ops/sec [60,703..63,128]	~ overlap (-3.1%)	84,823 ops/sec [83,862..90,123] → 84,092 ops/sec [81,986..93,673]	~ overlap (-0.9%)
exec() with capture groups	35,392 ops/sec [35,304..35,597] → 34,436 ops/sec [33,983..36,798]	~ overlap (-2.7%)	41,335 ops/sec [41,014..41,805] → 40,597 ops/sec [40,224..42,755]	~ overlap (-1.8%)
toString()	49,691 ops/sec [48,398..55,802] → 49,701 ops/sec [48,173..57,687]	~ overlap (+0.0%)	58,597 ops/sec [57,503..71,606] → 59,616 ops/sec [58,625..59,634]	~ overlap (+1.7%)
match() with global regex	22,384 ops/sec [22,169..22,648] → 22,802 ops/sec [21,477..22,863]	~ overlap (+1.9%)	27,246 ops/sec [27,144..27,382] → 26,381 ops/sec [25,653..28,439]	~ overlap (-3.2%)
match() with many global results	1,161 ops/sec [1,155..1,170] → 1,117 ops/sec [1,100..1,339]	~ overlap (-3.8%)	1,106 ops/sec [1,098..1,154] → 1,154 ops/sec [1,144..1,172]	~ overlap (+4.3%)
matchAll() with capture groups	7,631 ops/sec [7,476..7,722] → 7,643 ops/sec [7,507..9,382]	~ overlap (+0.2%)	10,548 ops/sec [10,230..10,992] → 10,935 ops/sec [10,859..11,027]	~ overlap (+3.7%)
replace() with global regex	20,908 ops/sec [20,487..21,112] → 20,566 ops/sec [20,192..21,778]	~ overlap (-1.6%)	25,237 ops/sec [23,808..25,534] → 26,188 ops/sec [24,728..27,376]	~ overlap (+3.8%)
replace() with many global results	885 ops/sec [852..1,099] → 876 ops/sec [836..911]	~ overlap (-1.0%)	854 ops/sec [836..873] → 846 ops/sec [844..850]	~ overlap (-1.0%)
search() with regex	41,273 ops/sec [39,501..44,135] → 40,150 ops/sec [39,613..59,744]	~ overlap (-2.7%)	54,676 ops/sec [54,600..54,773] → 54,218 ops/sec [53,539..54,712]	~ overlap (-0.8%)
split() with regex separator	10,003 ops/sec [9,720..10,197] → 10,898 ops/sec [9,588..12,087]	~ overlap (+8.9%)	10,957 ops/sec [10,288..13,902] → 10,622 ops/sec [10,584..10,878]	~ overlap (-3.1%)

strings.js — Interp: 🔴 1, 18 unch. · avg -1.1% · Bytecode: 🟢 4, 🔴 3, 12 unch. · avg +1.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
string concatenation	84,426 ops/sec [83,453..95,005] → 84,903 ops/sec [84,186..93,491]	~ overlap (+0.6%)	445,677 ops/sec [433,020..512,265] → 442,813 ops/sec [434,309..547,599]	~ overlap (-0.6%)
template literal	158,330 ops/sec [156,757..159,076] → 151,743 ops/sec [146,063..186,277]	~ overlap (-4.2%)	357,983 ops/sec [345,675..414,094] → 353,918 ops/sec [345,885..385,731]	~ overlap (-1.1%)
string repeat	99,819 ops/sec [91,863..109,852] → 96,385 ops/sec [94,596..109,710]	~ overlap (-3.4%)	121,617 ops/sec [120,932..122,057] → 124,509 ops/sec [121,765..143,021]	~ overlap (+2.4%)
split and join	41,839 ops/sec [41,135..53,934] → 42,436 ops/sec [42,313..44,175]	~ overlap (+1.4%)	57,107 ops/sec [56,368..57,491] → 59,363 ops/sec [58,961..60,215]	🟢 +4.0%
indexOf and includes	40,952 ops/sec [40,206..41,174] → 40,183 ops/sec [38,896..41,116]	~ overlap (-1.9%)	50,412 ops/sec [49,703..50,790] → 52,964 ops/sec [50,824..83,740]	🟢 +5.1%
toUpperCase and toLowerCase	38,007 ops/sec [37,727..38,156] → 38,306 ops/sec [36,387..39,351]	~ overlap (+0.8%)	45,361 ops/sec [44,467..45,745] → 49,016 ops/sec [45,514..50,460]	~ overlap (+8.1%)
slice and substring	37,604 ops/sec [37,161..38,417] → 36,724 ops/sec [35,405..48,800]	~ overlap (-2.3%)	52,716 ops/sec [52,406..53,044] → 53,888 ops/sec [52,010..58,349]	~ overlap (+2.2%)
trim operations	41,464 ops/sec [41,355..41,668] → 42,183 ops/sec [41,420..42,764]	~ overlap (+1.7%)	61,849 ops/sec [55,896..66,080] → 60,232 ops/sec [58,924..68,757]	~ overlap (-2.6%)
replace and replaceAll	48,105 ops/sec [47,370..52,528] → 47,963 ops/sec [45,893..57,689]	~ overlap (-0.3%)	60,888 ops/sec [58,265..64,970] → 58,457 ops/sec [57,611..59,944]	~ overlap (-4.0%)
startsWith and endsWith	31,747 ops/sec [31,212..34,137] → 30,930 ops/sec [30,623..33,189]	~ overlap (-2.6%)	40,408 ops/sec [38,564..46,597] → 39,390 ops/sec [38,732..39,567]	~ overlap (-2.5%)
padStart and padEnd	50,097 ops/sec [48,857..50,959] → 50,429 ops/sec [49,111..51,210]	~ overlap (+0.7%)	67,715 ops/sec [66,362..67,998] → 70,301 ops/sec [67,046..70,537]	~ overlap (+3.8%)
identity tag, no substitutions	104,671 ops/sec [101,322..106,615] → 103,373 ops/sec [102,284..105,621]	~ overlap (-1.2%)	149,013 ops/sec [145,519..156,996] → 154,646 ops/sec [154,322..154,810]	~ overlap (+3.8%)
tag with 1 substitution	23,233 ops/sec [22,305..23,755] → 23,421 ops/sec [23,107..24,444]	~ overlap (+0.8%)	29,905 ops/sec [29,769..30,147] → 30,564 ops/sec [30,222..30,795]	🟢 +2.2%
tag with 3 substitutions	13,180 ops/sec [12,734..15,487] → 12,874 ops/sec [12,530..12,999]	~ overlap (-2.3%)	18,356 ops/sec [17,915..18,755] → 18,275 ops/sec [18,112..18,437]	~ overlap (-0.4%)
tag with 6 substitutions	7,757 ops/sec [7,392..8,203] → 7,548 ops/sec [7,369..7,792]	~ overlap (-2.7%)	11,359 ops/sec [11,301..11,444] → 11,046 ops/sec [10,998..11,161]	🔴 -2.7%
String.raw, no substitutions	91,219 ops/sec [89,489..91,719] → 88,285 ops/sec [87,944..89,403]	🔴 -3.2%	91,937 ops/sec [90,851..92,360] → 89,904 ops/sec [89,566..90,540]	🔴 -2.2%
String.raw, 2 substitutions	62,981 ops/sec [62,566..64,487] → 62,550 ops/sec [61,420..64,927]	~ overlap (-0.7%)	72,842 ops/sec [72,574..73,922] → 72,049 ops/sec [70,999..72,230]	🔴 -1.1%
tag accessing .raw array	38,025 ops/sec [37,441..38,812] → 37,426 ops/sec [36,832..38,772]	~ overlap (-1.6%)	47,973 ops/sec [47,255..48,314] → 48,017 ops/sec [47,732..48,389]	~ overlap (+0.1%)
method as tag (this binding)	15,647 ops/sec [15,307..16,607] → 15,721 ops/sec [15,617..15,778]	~ overlap (+0.5%)	21,805 ops/sec [21,392..22,140] → 23,226 ops/sec [23,045..23,351]	🟢 +6.5%

temporal.js — Interp: 🔴 1, 5 unch. · avg +0.5% · Bytecode: 🟢 1, 5 unch. · avg +1.5%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
PlainDate.add({ months: 1 })	39,548 ops/sec [38,085..40,453] → 38,562 ops/sec [38,235..39,670]	~ overlap (-2.5%)	41,455 ops/sec [40,773..41,779] → 42,073 ops/sec [41,581..42,180]	~ overlap (+1.5%)
PlainDate.until(..., { largestUnit: 'months' })	45,393 ops/sec [43,977..53,258] → 45,404 ops/sec [44,976..46,180]	~ overlap (+0.0%)	48,971 ops/sec [48,527..49,033] → 52,124 ops/sec [49,370..57,964]	🟢 +6.4%
Duration.total days relative to PlainDate	38,574 ops/sec [37,475..43,845] → 39,522 ops/sec [38,678..41,543]	~ overlap (+2.5%)	39,011 ops/sec [37,997..42,990] → 39,810 ops/sec [39,243..50,416]	~ overlap (+2.0%)
Duration.round to hours	31,008 ops/sec [30,663..31,963] → 33,278 ops/sec [30,810..36,652]	~ overlap (+7.3%)	32,669 ops/sec [31,105..35,914] → 32,252 ops/sec [32,061..32,617]	~ overlap (-1.3%)
ZonedDateTime.from named time zone	8,769 ops/sec [8,431..8,942] → 8,719 ops/sec [8,549..11,058]	~ overlap (-0.6%)	8,937 ops/sec [8,695..9,368] → 8,885 ops/sec [8,385..9,723]	~ overlap (-0.6%)
ZonedDateTime.since across DST	9,753 ops/sec [9,444..10,625] → 9,381 ops/sec [9,370..9,414]	🔴 -3.8%	9,936 ops/sec [9,687..11,224] → 10,015 ops/sec [9,723..17,354]	~ overlap (+0.8%)

tsv.js — Interp: 🔴 2, 7 unch. · avg -2.1% · Bytecode: 9 unch. · avg +2.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple 3-column TSV	38,783 ops/sec [38,365..39,385] → 38,295 ops/sec [37,849..38,869]	~ overlap (-1.3%)	37,791 ops/sec [36,657..38,641] → 38,246 ops/sec [37,363..38,579]	~ overlap (+1.2%)
parse 10-row TSV	11,389 ops/sec [11,045..12,584] → 11,263 ops/sec [11,062..11,592]	~ overlap (-1.1%)	11,068 ops/sec [10,901..11,249] → 11,313 ops/sec [11,230..11,693]	~ overlap (+2.2%)
parse 100-row TSV	1,879 ops/sec [1,691..2,110] → 1,840 ops/sec [1,798..2,001]	~ overlap (-2.1%)	1,788 ops/sec [1,770..2,379] → 1,804 ops/sec [1,785..1,818]	~ overlap (+0.9%)
parse TSV with backslash-escaped fields	9,322 ops/sec [8,938..10,571] → 9,360 ops/sec [9,039..10,384]	~ overlap (+0.4%)	9,198 ops/sec [8,810..9,654] → 9,186 ops/sec [9,095..9,252]	~ overlap (-0.1%)
parse without headers (array of arrays)	5,758 ops/sec [5,745..5,764] → 5,566 ops/sec [5,432..6,070]	~ overlap (-3.3%)	5,421 ops/sec [5,369..6,227] → 5,968 ops/sec [5,415..6,472]	~ overlap (+10.1%)
stringify array of objects	12,162 ops/sec [11,945..12,949] → 11,864 ops/sec [11,757..11,986]	~ overlap (-2.5%)	12,500 ops/sec [12,336..14,188] → 12,139 ops/sec [12,101..14,032]	~ overlap (-2.9%)
stringify array of arrays	3,247 ops/sec [3,062..3,541] → 3,086 ops/sec [3,062..3,129]	~ overlap (-5.0%)	3,127 ops/sec [3,073..3,131] → 3,445 ops/sec [3,046..3,735]	~ overlap (+10.2%)
stringify with values needing escaping	9,887 ops/sec [9,874..9,910] → 9,780 ops/sec [9,546..9,849]	🔴 -1.1%	10,007 ops/sec [9,752..10,064] → 10,037 ops/sec [10,021..10,066]	~ overlap (+0.3%)
parse then stringify	3,930 ops/sec [3,887..4,406] → 3,819 ops/sec [3,725..3,867]	🔴 -2.8%	3,858 ops/sec [3,726..3,938] → 3,775 ops/sec [3,660..4,068]	~ overlap (-2.2%)

typed-arrays.js — Interp: 🟢 3, 🔴 5, 14 unch. · avg -8.7% · Bytecode: 🟢 6, 🔴 4, 12 unch. · avg -4.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
new Int32Array(0)	104,830 ops/sec [102,158..136,506] → 104,589 ops/sec [104,018..104,704]	~ overlap (-0.2%)	129,629 ops/sec [126,374..149,738] → 130,624 ops/sec [127,533..133,183]	~ overlap (+0.8%)
new Int32Array(100)	99,723 ops/sec [98,625..100,128] → 98,209 ops/sec [96,976..99,014]	~ overlap (-1.5%)	121,984 ops/sec [120,671..124,924] → 121,196 ops/sec [118,706..124,853]	~ overlap (-0.6%)
new Int32Array(1000)	75,575 ops/sec [74,518..75,957] → 76,175 ops/sec [74,930..76,796]	~ overlap (+0.8%)	88,808 ops/sec [88,550..89,393] → 90,288 ops/sec [88,849..90,842]	~ overlap (+1.7%)
new Float64Array(100)	92,379 ops/sec [91,839..92,654] → 95,121 ops/sec [93,953..106,719]	🟢 +3.0%	115,171 ops/sec [114,061..118,424] → 116,662 ops/sec [115,840..117,429]	~ overlap (+1.3%)
Int32Array.from([...])	1,192 ops/sec [1,178..1,220] → 1,245 ops/sec [1,221..1,253]	🟢 +4.5%	1,186 ops/sec [1,169..1,301] → 1,218 ops/sec [1,203..1,227]	~ overlap (+2.7%)
Int32Array.of(1, 2, 3, 4, 5)	63,605 ops/sec [62,942..63,866] → 62,949 ops/sec [61,579..65,294]	~ overlap (-1.0%)	75,558 ops/sec [74,568..79,270] → 79,564 ops/sec [75,641..82,087]	~ overlap (+5.3%)
sequential write 100 elements	1,000 ops/sec [939..1,494] → 979 ops/sec [954..1,538]	~ overlap (-2.0%)	7,071 ops/sec [6,972..7,160] → 6,983 ops/sec [6,813..7,059]	~ overlap (-1.2%)
sequential read 100 elements	1,548 ops/sec [1,523..1,579] → 1,577 ops/sec [1,562..1,590]	~ overlap (+1.9%)	7,876 ops/sec [7,856..7,944] → 7,908 ops/sec [7,769..8,018]	~ overlap (+0.4%)
Float64Array write 100 elements	1,371 ops/sec [1,367..1,380] → 889 ops/sec [869..895]	🔴 -35.1%	5,741 ops/sec [5,681..5,811] → 5,722 ops/sec [5,682..6,477]	~ overlap (-0.3%)
fill(42)	10,210 ops/sec [10,129..10,260] → 10,158 ops/sec [10,124..10,186]	~ overlap (-0.5%)	5,548 ops/sec [5,414..5,586] → 5,556 ops/sec [5,547..5,575]	~ overlap (+0.1%)
slice()	78,001 ops/sec [77,474..78,563] → 78,351 ops/sec [77,407..78,675]	~ overlap (+0.4%)	57,195 ops/sec [44,608..58,382] → 59,792 ops/sec [58,870..93,471]	🟢 +4.5%
map(x => x * 2)	3,115 ops/sec [3,037..3,138] → 3,045 ops/sec [3,008..3,068]	~ overlap (-2.2%)	3,323 ops/sec [3,262..3,351] → 3,422 ops/sec [3,406..3,473]	🟢 +3.0%
filter(x => x > 50)	3,162 ops/sec [3,151..3,177] → 1,917 ops/sec [1,893..3,133]	🔴 -39.4%	3,560 ops/sec [3,533..3,577] → 3,615 ops/sec [3,584..3,631]	🟢 +1.5%
reduce (sum)	3,052 ops/sec [3,019..3,084] → 1,886 ops/sec [1,864..1,910]	🔴 -38.2%	3,335 ops/sec [3,330..3,341] → 3,364 ops/sec [3,359..3,378]	🟢 +0.9%
sort()	37,350 ops/sec [36,887..37,575] → 21,133 ops/sec [21,034..21,219]	🔴 -43.4%	39,006 ops/sec [38,872..39,165] → 39,257 ops/sec [39,054..39,353]	~ overlap (+0.6%)
indexOf()	45,158 ops/sec [44,828..45,698] → 26,950 ops/sec [26,815..27,154]	🔴 -40.3%	49,184 ops/sec [48,857..49,312] → 48,442 ops/sec [47,916..49,363]	~ overlap (-1.5%)
reverse()	46,095 ops/sec [45,805..46,366] → 45,949 ops/sec [45,731..46,119]	~ overlap (-0.3%)	48,894 ops/sec [48,630..49,065] → 26,922 ops/sec [26,268..29,426]	🔴 -44.9%
create view over existing buffer	193,719 ops/sec [192,495..196,703] → 196,084 ops/sec [192,615..197,735]	~ overlap (+1.2%)	276,456 ops/sec [273,771..277,028] → 174,029 ops/sec [168,392..190,533]	🔴 -37.1%
subarray()	91,698 ops/sec [89,675..92,582] → 91,157 ops/sec [89,984..92,693]	~ overlap (-0.6%)	108,017 ops/sec [105,847..109,479] → 69,275 ops/sec [69,096..69,555]	🔴 -35.9%
set() from array	106,719 ops/sec [104,965..107,621] → 105,190 ops/sec [104,355..105,885]	~ overlap (-1.4%)	127,363 ops/sec [126,852..127,741] → 129,020 ops/sec [128,391..129,490]	🟢 +1.3%
for-of loop	2,070 ops/sec [2,060..2,075] → 2,086 ops/sec [2,045..2,106]	~ overlap (+0.8%)	17,308 ops/sec [17,129..17,378] → 17,665 ops/sec [17,416..17,805]	🟢 +2.1%
spread into array	8,317 ops/sec [8,268..8,366] → 8,572 ops/sec [8,433..8,646]	🟢 +3.1%	31,903 ops/sec [31,663..32,361] → 31,271 ops/sec [31,189..31,305]	🔴 -2.0%

uint8array-encoding.js — Interp: 🟢 7, 🔴 1, 10 unch. · avg +13.3% · Bytecode: 🟢 8, 🔴 1, 9 unch. · avg +17.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
short (5 bytes)	149,534 ops/sec [127,681..154,655] → 129,021 ops/sec [127,387..129,797]	~ overlap (-13.7%)	163,800 ops/sec [162,169..166,875] → 164,340 ops/sec [159,927..168,342]	~ overlap (+0.3%)
medium (450 bytes)	85,612 ops/sec [84,961..86,177] → 89,440 ops/sec [86,390..90,694]	🟢 +4.5%	102,972 ops/sec [100,703..103,593] → 100,880 ops/sec [100,521..105,617]	~ overlap (-2.0%)
large (4096 bytes)	23,552 ops/sec [23,443..23,703] → 24,500 ops/sec [24,248..24,844]	🟢 +4.0%	24,106 ops/sec [23,937..24,390] → 25,232 ops/sec [25,031..25,378]	🟢 +4.7%
base64url alphabet	65,978 ops/sec [65,553..66,206] → 66,040 ops/sec [65,952..66,315]	~ overlap (+0.1%)	67,837 ops/sec [67,803..68,735] → 71,804 ops/sec [71,154..72,491]	🟢 +5.8%
omitPadding	94,658 ops/sec [90,493..144,680] → 90,195 ops/sec [89,779..92,685]	~ overlap (-4.7%)	98,542 ops/sec [98,048..98,595] → 100,499 ops/sec [99,646..100,927]	🟢 +2.0%
short (8 chars)	153,327 ops/sec [151,615..153,914] → 96,903 ops/sec [96,383..97,789]	🔴 -36.8%	108,933 ops/sec [107,584..111,187] → 109,820 ops/sec [109,536..110,583]	~ overlap (+0.8%)
medium (600 chars)	19,436 ops/sec [18,702..19,852] → 19,058 ops/sec [18,693..19,361]	~ overlap (-1.9%)	19,604 ops/sec [19,103..19,788] → 19,298 ops/sec [18,622..19,726]	~ overlap (-1.6%)
large (5464 chars)	2,537 ops/sec [2,477..2,993] → 2,848 ops/sec [2,504..3,103]	~ overlap (+12.2%)	2,503 ops/sec [2,483..2,522] → 2,488 ops/sec [2,475..2,536]	~ overlap (-0.6%)
short (5 bytes)	131,510 ops/sec [130,975..134,266] → 129,275 ops/sec [121,779..134,158]	~ overlap (-1.7%)	175,118 ops/sec [174,395..181,833] → 174,147 ops/sec [172,787..174,293]	🔴 -0.6%
medium (450 bytes)	81,541 ops/sec [80,385..90,030] → 84,967 ops/sec [82,788..87,333]	~ overlap (+4.2%)	95,022 ops/sec [93,863..95,196] → 95,663 ops/sec [95,213..96,036]	🟢 +0.7%
large (4096 bytes)	19,462 ops/sec [19,102..20,632] → 19,653 ops/sec [19,256..20,682]	~ overlap (+1.0%)	20,005 ops/sec [19,916..20,075] → 20,248 ops/sec [19,971..20,850]	~ overlap (+1.2%)
short (10 chars)	108,632 ops/sec [107,511..109,055] → 110,776 ops/sec [110,234..111,452]	🟢 +2.0%	124,174 ops/sec [123,320..125,560] → 203,404 ops/sec [202,456..203,709]	🟢 +63.8%
medium (900 chars)	85,673 ops/sec [79,068..95,036] → 83,101 ops/sec [81,609..84,124]	~ overlap (-3.0%)	89,373 ops/sec [88,925..90,007] → 151,138 ops/sec [150,294..151,755]	🟢 +69.1%
large (8192 chars)	27,321 ops/sec [26,143..35,690] → 27,314 ops/sec [26,907..48,269]	~ overlap (-0.0%)	27,174 ops/sec [26,347..27,413] → 50,628 ops/sec [50,279..50,752]	🟢 +86.3%
setFromBase64 (450 bytes)	18,011 ops/sec [17,798..18,134] → 31,549 ops/sec [31,168..31,746]	🟢 +75.2%	19,140 ops/sec [18,651..20,199] → 33,195 ops/sec [33,118..33,361]	🟢 +73.4%
setFromHex (450 bytes)	21,317 ops/sec [21,245..21,451] → 35,600 ops/sec [35,329..35,671]	🟢 +67.0%	21,950 ops/sec [21,636..22,069] → 22,216 ops/sec [21,808..22,403]	~ overlap (+1.2%)
toBase64 → fromBase64 (450 bytes)	16,748 ops/sec [16,505..16,813] → 28,298 ops/sec [28,182..28,362]	🟢 +69.0%	16,960 ops/sec [16,897..17,083] → 17,049 ops/sec [16,873..17,421]	~ overlap (+0.5%)
toHex → fromHex (450 bytes)	47,044 ops/sec [46,877..47,330] → 76,613 ops/sec [75,934..76,898]	🟢 +62.9%	51,180 ops/sec [50,552..51,722] → 51,856 ops/sec [51,267..52,093]	~ overlap (+1.3%)

weak-collections.js — Interp: 🟢 3, 🔴 1, 11 unch. · avg +12.5% · Bytecode: 🟢 4, 🔴 4, 7 unch. · avg -1.3%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
constructor from 50 entries	7,928 ops/sec [7,780..9,010] → 7,530 ops/sec [7,223..8,484]	~ overlap (-5.0%)	8,261 ops/sec [8,118..8,526] → 7,815 ops/sec [7,352..8,696]	~ overlap (-5.4%)
set 50 object keys	2,563 ops/sec [2,426..2,628] → 2,493 ops/sec [2,429..2,522]	~ overlap (-2.8%)	3,363 ops/sec [3,337..3,388] → 3,281 ops/sec [3,276..3,297]	🔴 -2.4%
get lookups (50 entries)	56,591 ops/sec [35,955..57,025] → 38,699 ops/sec [34,266..55,260]	~ overlap (-31.6%)	69,192 ops/sec [67,347..69,596] → 71,837 ops/sec [70,935..72,101]	🟢 +3.8%
has checks (50 entries)	47,553 ops/sec [45,861..48,290] → 72,788 ops/sec [45,408..73,902]	~ overlap (+53.1%)	86,369 ops/sec [85,842..86,783] → 90,910 ops/sec [89,680..91,557]	🟢 +5.3%
delete entries	2,368 ops/sec [2,345..2,384] → 2,304 ops/sec [2,289..3,725]	~ overlap (-2.7%)	3,143 ops/sec [3,107..3,150] → 3,175 ops/sec [3,164..3,248]	🟢 +1.0%
non-registered symbol keys	5,704 ops/sec [5,670..5,778] → 9,059 ops/sec [5,582..9,080]	~ overlap (+58.8%)	7,631 ops/sec [7,609..7,648] → 7,694 ops/sec [7,654..7,786]	🟢 +0.8%
getOrInsert	2,238 ops/sec [2,198..2,251] → 2,251 ops/sec [2,159..2,267]	~ overlap (+0.6%)	3,030 ops/sec [3,002..3,050] → 2,952 ops/sec [2,933..2,960]	🔴 -2.6%
getOrInsertComputed	1,385 ops/sec [1,377..1,396] → 1,419 ops/sec [1,403..1,423]	🟢 +2.5%	1,626 ops/sec [1,614..1,643] → 1,606 ops/sec [1,542..1,616]	~ overlap (-1.2%)
forced gc live-key retention	735 ops/sec [616..997] → 779 ops/sec [691..999]	~ overlap (+6.0%)	992 ops/sec [918..998] → 768 ops/sec [633..859]	🔴 -22.6%
constructor from 50 values	9,550 ops/sec [9,268..9,677] → 13,406 ops/sec [8,821..15,399]	~ overlap (+40.4%)	9,716 ops/sec [9,651..10,021] → 9,489 ops/sec [8,879..9,956]	~ overlap (-2.3%)
add 50 object values	2,702 ops/sec [2,696..2,763] → 4,174 ops/sec [3,659..4,192]	🟢 +54.5%	3,485 ops/sec [3,458..3,530] → 3,479 ops/sec [3,464..3,519]	~ overlap (-0.2%)
has checks (50 values)	47,348 ops/sec [46,832..48,112] → 73,525 ops/sec [73,160..73,728]	🟢 +55.3%	88,026 ops/sec [86,409..89,938] → 93,592 ops/sec [88,626..106,474]	~ overlap (+6.3%)
delete values	12,250 ops/sec [7,179..12,313] → 11,961 ops/sec [11,903..11,980]	~ overlap (-2.4%)	13,851 ops/sec [8,235..14,589] → 14,337 ops/sec [14,157..14,871]	~ overlap (+3.5%)
non-registered symbol values	9,297 ops/sec [9,087..9,401] → 9,333 ops/sec [9,290..9,343]	~ overlap (+0.4%)	13,555 ops/sec [13,418..13,604] → 13,549 ops/sec [13,515..13,578]	~ overlap (-0.0%)
forced gc pruning smoke	1,673 ops/sec [1,474..1,792] → 1,003 ops/sec [918..1,010]	🔴 -40.0%	1,791 ops/sec [1,787..1,794] → 1,740 ops/sec [1,735..1,750]	🔴 -2.8%

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]

JetStream 3 Performance Barometer

Workload	Status	Goccia main	Goccia PR	QuickJS	Node.js	vs QuickJS	vs Node.js
hash-map	pass	0.52	0.52	13.77	349.45	26.23×	665.65×
ai-astar	pass	1.76	1.76	48.69	349.29	27.73×	198.93×
gaussian-blur	pass	0.35	0.35	7.59	271.06	21.79×	778.23×
raytrace-public-class-fields	pass	0.40	0.40	11.17	200.64	27.85×	500.13×
sync-fs	pass	0.91	0.88	27.26	223.69	31.03×	254.67×
lazy-collections	pass	2.04	2.04	68.42	147.55	33.51×	72.27×

Geomean reference ratio: QuickJS 27.78×; Node.js 313.46×.

_{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]

AWFY Results

AWFY results were not produced for this run: awfy-report.json is missing.

_{See the workflow run for the failing step.}

[github-actions]

test262 Conformance

test262 results were not produced for this run.

_{Non-blocking. The conformance job either timed out, crashed, or did not upload an artifact. See the workflow run for details.}