docs(release): sync source truth and generated data

[frostney]

Summary

• Synchronize release-readiness documentation and website claims with the current implementation, compiler support, and measured production binary sizes.
• Refresh pinned JSON5/YAML compatibility snapshots and the generated Unicode 17.0.0 fallback blob.
• Make Fumadocs source generation part of fresh installs and keep the unreleased changelog out of the fallback Other group.

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,517/11,517 each), Pascal formatting (428 files), website tests/lint/typecheck/production build, documentation structural checks, generated-data byte comparison, embedded-resource smoke tests, and changelog preview.

[vercel]

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

Project	Deployment	Actions	Updated (UTC)
gocciascript-homepage	Ready	Preview, Comment	Jul 21, 2026 8:00am

[coderabbitai]

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro Plus

Run ID: f5a06f00-281e-45dc-b990-120806301931

📥 Commits

Reviewing files that changed from the base of the PR and between 31c2977 and 1608848.

⛔ Files ignored due to path filters (1)

• source/generated/Generated.UnicodeData.Blob.inc is excluded by !**/generated/**

📒 Files selected for processing (8)

• cliff.toml
• docs/built-ins.md
• docs/interpreter.md
• docs/language-tables.md
• website/package.json
• website/src/components/landing.tsx
• website/src/lib/landing-data.ts
• website/src/lib/positioning.ts

---

📝 Walkthrough

Walkthrough

Updates git-cliff categorization, documentation snapshots and terminology, website installation setup, and public landing-page, positioning, and module-format descriptions.

Changes

Changelog classification

Layer / File(s)	Summary
Wasm commit grouping cliff.toml	Commit messages beginning with Wasm support are assigned to the “🚀 Added” changelog group.

Documentation accuracy

Layer / File(s)	Summary
Proposal and specification documentation docs/built-ins.md, docs/language-tables.md	Goccia’s proposal inventory is described as selected, and the specification years for two ECMAScript features are corrected.
Compatibility snapshots docs/interpreter.md	JSON5 and YAML compatibility records now reference updated dates, upstream revisions, and result counts.

Website setup and messaging

Layer / File(s)	Summary
Website content generation setup website/package.json	Adds a postinstall hook that runs fumadocs-mdx.
Landing and positioning copy website/src/components/landing.tsx, website/src/lib/positioning.ts	Updates application use cases, Delphi 12 support, runtime wording, and compiler-support descriptions.
Module format feature copy website/src/lib/landing-data.ts	Adds JSON5 and TSV to the listed direct module import formats.

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

Possibly related PRs

• frostney/GocciaScript#248: Updates the same git-cliff commit-parser configuration.
• frostney/GocciaScript#445: Also changes website landing-page content.
• frostney/GocciaScript#982: Overlaps with the website landing and positioning copy changes.

Suggested labels: documentation, spec compliance, internal

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 0.00% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (4 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title concisely matches the PR's docs and generated-data sync changes.
Description check	✅ Passed	The description follows the required Summary and Testing sections and includes relevant verification details.
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.

Warning

There were issues while running some tools. Please review the errors and either fix the tool's configuration or disable the tool if it's a critical failure.

🔧 Checkov (3.3.8)

website/package.json

Traceback (most recent call last):
File "/usr/local/bin/checkov", line 2, in
from checkov.main import Checkov
ModuleNotFoundError: No module named 'checkov'

---

_{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.02 runs/s
babel-minify	pass	0.10 runs/s
babylon	pass	0.04 runs/s
buble	pass	0.09 runs/s
chai	pass	0.09 runs/s
coffeescript	pass	0.02 runs/s
espree	pass	0.02 runs/s
esprima	pass	0.04 runs/s
jshint	pass	0.02 runs/s
lebab	pass	0.07 runs/s
postcss	pass	0.02 runs/s
prepack	pass	0.11 runs/s
prettier	pass	0.06 runs/s
source-map	pass	0.03 runs/s
terser	pass	211 runs/s
typescript	pass	0.10 runs/s
uglify-js	pass	187 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]

JetStream 3 Performance Barometer

Workload	Status	Goccia main	Goccia PR	QuickJS	Node.js	vs QuickJS	vs Node.js
hash-map	pass	0.53	0.52	13.59	328.63	25.95×	627.46×
ai-astar	pass	1.70	1.72	41.07	351.09	23.90×	204.31×
gaussian-blur	pass	0.56	0.55	11.85	360.46	21.36×	649.77×
raytrace-public-class-fields	pass	0.57	0.57	14.98	255.66	26.46×	451.70×
sync-fs	pass	0.92	0.88	27.14	234.44	30.95×	267.36×
lazy-collections	pass	1.95	1.95	68.02	150.01	34.93×	77.04×

Geomean reference ratio: QuickJS 26.90×; Node.js 303.07×.

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

Suite Timing

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

Metric	Interpreted	Bytecode
Total	11517	11517
Passed	11517 ✅	11517 ✅
Workers	4	4
Test Duration	18.64s	18.14s
Lex (cumulative)	1.78s	1.90s
Parse (cumulative)	996.5ms	1.03s
Compile (cumulative)	—	1.18s
Execute (cumulative)	951.1ms	15.95s
Engine Total (cumulative)	3.73s	20.06s
Lex (avg/worker)	446.1ms	475.9ms
Parse (avg/worker)	249.1ms	258.5ms
Compile (avg/worker)	—	294.9ms
Execute (avg/worker)	237.8ms	3.99s
Engine Total (avg/worker)	933.0ms	5.02s

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	64.99 MiB	62.85 MiB
GC Peak Live	221.17 MiB	185.49 MiB
GC Allocated During Run	521.35 MiB	454.36 MiB
GC Limit	7.81 GiB	7.81 GiB
GC Collections	226	226
GC Collected Objects	4,386,935	3,840,601
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.17min	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.84 MiB	95.30 MiB
GC Allocated During Run	15.69 GiB	12.39 GiB
GC Limit	7.81 GiB	7.81 GiB
GC Collections	7,791	6,624
GC Collected Objects	228,487,780	272,374,147
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.2ms	7.3ms
Boot (min)	7.0ms	7.2ms

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: 🟢 36 improved · 🔴 25 regressed · 378 unchanged · avg +1.2%
Bytecode: 🟢 99 improved · 🔴 20 regressed · 320 unchanged · avg +4.6%

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

arraybuffer.js — Interp: 🟢 1, 13 unch. · avg +0.8% · Bytecode: 🔴 1, 13 unch. · avg +1.6%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
create ArrayBuffer(0)	96,954 ops/sec [95,407..127,111] → 96,524 ops/sec [94,250..108,048]	~ overlap (-0.4%)	195,345 ops/sec [190,630..204,754] → 207,011 ops/sec [200,145..211,091]	~ overlap (+6.0%)
create ArrayBuffer(64)	104,545 ops/sec [89,754..109,085] → 94,401 ops/sec [93,713..94,901]	~ overlap (-9.7%)	188,612 ops/sec [185,624..217,863] → 191,167 ops/sec [185,373..199,178]	~ overlap (+1.4%)
create ArrayBuffer(1024)	86,841 ops/sec [83,221..113,783] → 86,087 ops/sec [81,319..100,126]	~ overlap (-0.9%)	166,203 ops/sec [165,745..169,923] → 157,290 ops/sec [153,623..167,925]	~ overlap (-5.4%)
create ArrayBuffer(8192)	58,826 ops/sec [57,890..72,812] → 59,017 ops/sec [58,192..70,137]	~ overlap (+0.3%)	99,996 ops/sec [95,529..111,099] → 96,917 ops/sec [93,854..97,552]	~ overlap (-3.1%)
slice full buffer (64 bytes)	72,692 ops/sec [71,714..76,935] → 76,658 ops/sec [73,348..81,101]	~ overlap (+5.5%)	121,441 ops/sec [118,603..125,693] → 124,276 ops/sec [118,652..127,929]	~ overlap (+2.3%)
slice half buffer (512 of 1024 bytes)	67,065 ops/sec [65,313..68,032] → 69,552 ops/sec [68,292..70,798]	🟢 +3.7%	108,712 ops/sec [105,327..132,722] → 118,166 ops/sec [115,318..139,471]	~ overlap (+8.7%)
slice with negative indices	61,833 ops/sec [60,541..65,294] → 65,131 ops/sec [64,723..65,553]	~ overlap (+5.3%)	118,297 ops/sec [114,077..118,588] → 118,508 ops/sec [116,684..121,840]	~ overlap (+0.2%)
slice empty range	71,235 ops/sec [70,684..72,176] → 71,795 ops/sec [71,039..72,097]	~ overlap (+0.8%)	116,283 ops/sec [115,240..118,297] → 121,377 ops/sec [114,687..127,836]	~ overlap (+4.4%)
byteLength access	180,608 ops/sec [173,953..187,484] → 187,276 ops/sec [186,051..207,632]	~ overlap (+3.7%)	305,045 ops/sec [290,508..317,556] → 307,810 ops/sec [301,496..314,420]	~ overlap (+0.9%)
Symbol.toStringTag access	176,157 ops/sec [172,816..189,876] → 180,823 ops/sec [171,952..182,201]	~ overlap (+2.6%)	273,321 ops/sec [261,899..280,844] → 284,344 ops/sec [273,670..286,339]	~ overlap (+4.0%)
ArrayBuffer.isView	134,194 ops/sec [133,675..134,792] → 134,975 ops/sec [132,587..144,849]	~ overlap (+0.6%)	257,076 ops/sec [247,285..278,024] → 266,772 ops/sec [256,277..299,338]	~ overlap (+3.8%)
clone ArrayBuffer(64)	105,169 ops/sec [105,073..105,450] → 104,999 ops/sec [104,019..111,962]	~ overlap (-0.2%)	191,629 ops/sec [189,042..205,451] → 204,565 ops/sec [185,058..211,455]	~ overlap (+6.8%)
clone ArrayBuffer(1024)	95,266 ops/sec [94,838..95,623] → 95,056 ops/sec [81,985..105,907]	~ overlap (-0.2%)	178,694 ops/sec [178,182..182,463] → 169,140 ops/sec [164,422..174,974]	🔴 -5.3%
clone ArrayBuffer inside object	68,752 ops/sec [68,592..69,379] → 69,125 ops/sec [68,776..70,264]	~ overlap (+0.5%)	117,938 ops/sec [115,667..119,428] → 114,631 ops/sec [111,787..133,178]	~ overlap (-2.8%)

arrays.js — Interp: 19 unch. · avg +0.4% · Bytecode: 19 unch. · avg -2.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Array.from length 100	2,272 ops/sec [2,241..2,305] → 2,201 ops/sec [1,855..2,302]	~ overlap (-3.1%)	2,665 ops/sec [2,381..3,082] → 2,803 ops/sec [2,754..3,327]	~ overlap (+5.2%)
Array.from 10 elements	14,095 ops/sec [11,887..14,364] → 15,416 ops/sec [14,166..16,526]	~ overlap (+9.4%)	23,004 ops/sec [20,716..24,753] → 20,416 ops/sec [19,872..21,006]	~ overlap (-11.3%)
Array.of 10 elements	46,169 ops/sec [44,553..48,261] → 46,983 ops/sec [44,990..54,044]	~ overlap (+1.8%)	77,206 ops/sec [72,143..87,933] → 79,551 ops/sec [72,209..83,596]	~ overlap (+3.0%)
spread into new array	70,152 ops/sec [69,048..76,802] → 70,089 ops/sec [67,627..72,853]	~ overlap (-0.1%)	56,015 ops/sec [52,736..58,832] → 53,377 ops/sec [50,871..56,435]	~ overlap (-4.7%)
map over 50 elements	3,968 ops/sec [3,904..3,972] → 3,951 ops/sec [3,847..3,983]	~ overlap (-0.4%)	5,665 ops/sec [5,249..6,928] → 5,871 ops/sec [5,553..5,962]	~ overlap (+3.6%)
filter over 50 elements	4,070 ops/sec [4,006..5,470] → 3,976 ops/sec [3,853..4,012]	~ overlap (-2.3%)	5,644 ops/sec [5,539..5,847] → 5,900 ops/sec [5,717..6,132]	~ overlap (+4.5%)
reduce sum 50 elements	4,720 ops/sec [4,676..5,969] → 4,700 ops/sec [4,612..4,715]	~ overlap (-0.4%)	6,439 ops/sec [6,182..6,518] → 6,479 ops/sec [6,275..6,787]	~ overlap (+0.6%)
forEach over 50 elements	3,289 ops/sec [3,270..3,306] → 3,266 ops/sec [3,162..3,377]	~ overlap (-0.7%)	6,968 ops/sec [6,522..7,728] → 6,480 ops/sec [6,330..6,758]	~ overlap (-7.0%)
find in 50 elements	6,418 ops/sec [6,344..6,885] → 6,648 ops/sec [6,589..7,150]	~ overlap (+3.6%)	8,221 ops/sec [8,087..8,675] → 8,288 ops/sec [8,154..8,522]	~ overlap (+0.8%)
sort 20 elements	3,533 ops/sec [3,512..3,604] → 3,836 ops/sec [3,442..4,031]	~ overlap (+8.6%)	4,883 ops/sec [4,751..4,983] → 4,767 ops/sec [4,613..4,858]	~ overlap (-2.4%)
flat nested array	26,778 ops/sec [26,759..26,867] → 26,820 ops/sec [26,563..28,745]	~ overlap (+0.2%)	41,999 ops/sec [40,107..44,936] → 39,912 ops/sec [38,770..40,110]	~ overlap (-5.0%)
flatMap	16,095 ops/sec [16,010..16,127] → 16,166 ops/sec [15,607..16,296]	~ overlap (+0.4%)	23,442 ops/sec [22,150..28,278] → 23,462 ops/sec [23,147..23,666]	~ overlap (+0.1%)
map inside map (5x5)	4,756 ops/sec [4,693..4,766] → 4,830 ops/sec [4,766..5,259]	~ overlap (+1.6%)	6,945 ops/sec [6,593..7,151] → 6,476 ops/sec [6,316..6,976]	~ overlap (-6.7%)
filter inside map (5x10)	3,052 ops/sec [2,964..3,200] → 3,102 ops/sec [3,075..3,112]	~ overlap (+1.6%)	4,673 ops/sec [4,519..4,845] → 4,463 ops/sec [4,313..4,690]	~ overlap (-4.5%)
reduce inside map (5x10)	3,706 ops/sec [3,617..3,739] → 3,743 ops/sec [3,623..3,872]	~ overlap (+1.0%)	5,235 ops/sec [5,085..5,450] → 5,021 ops/sec [4,941..5,136]	~ overlap (-4.1%)
forEach inside forEach (5x10)	2,844 ops/sec [2,682..2,942] → 2,737 ops/sec [2,706..2,754]	~ overlap (-3.7%)	5,819 ops/sec [5,773..5,997] → 5,443 ops/sec [5,338..5,986]	~ overlap (-6.5%)
find inside some (10x10)	3,067 ops/sec [2,854..3,438] → 2,835 ops/sec [2,806..2,890]	~ overlap (-7.5%)	4,013 ops/sec [3,966..4,155] → 3,888 ops/sec [3,746..4,038]	~ overlap (-3.1%)
map+filter chain nested (5x20)	965 ops/sec [886..1,095] → 937 ops/sec [924..947]	~ overlap (-2.9%)	1,360 ops/sec [1,341..1,388] → 1,293 ops/sec [1,260..1,357]	~ overlap (-5.0%)
reduce flatten (10x5)	6,608 ops/sec [6,501..6,629] → 6,651 ops/sec [6,624..7,416]	~ overlap (+0.7%)	3,399 ops/sec [3,384..3,532] → 3,431 ops/sec [3,202..3,511]	~ overlap (+0.9%)

async-await.js — Interp: 6 unch. · avg +0.8% · Bytecode: 🟢 1, 🔴 1, 4 unch. · avg +1.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
single await	19,936 ops/sec [18,469..23,178] → 20,056 ops/sec [17,784..21,016]	~ overlap (+0.6%)	33,474 ops/sec [30,554..34,700] → 32,843 ops/sec [27,956..33,649]	~ overlap (-1.9%)
multiple awaits	8,028 ops/sec [7,493..9,347] → 8,231 ops/sec [7,982..9,704]	~ overlap (+2.5%)	12,277 ops/sec [11,643..14,939] → 11,801 ops/sec [11,509..12,536]	~ overlap (-3.9%)
await non-Promise value	28,666 ops/sec [27,982..29,077] → 28,492 ops/sec [28,101..33,803]	~ overlap (-0.6%)	50,049 ops/sec [47,924..50,769] → 46,293 ops/sec [43,675..47,293]	🔴 -7.5%
await with try/catch	18,272 ops/sec [17,903..22,508] → 19,158 ops/sec [17,795..19,724]	~ overlap (+4.8%)	33,441 ops/sec [30,534..36,452] → 35,288 ops/sec [32,883..37,024]	~ overlap (+5.5%)
await Promise.all	4,897 ops/sec [4,814..5,567] → 4,920 ops/sec [4,781..5,098]	~ overlap (+0.5%)	6,189 ops/sec [5,753..6,268] → 7,205 ops/sec [7,059..7,625]	🟢 +16.4%
nested async function call	11,113 ops/sec [10,051..12,102] → 10,802 ops/sec [10,355..11,270]	~ overlap (-2.8%)	20,046 ops/sec [18,518..20,573] → 20,029 ops/sec [19,875..20,343]	~ overlap (-0.1%)

async-generators.js — Interp: 2 unch. · avg +2.8% · Bytecode: 2 unch. · avg +0.6%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for-await-of over async generator	1,271 ops/sec [1,214..1,340] → 1,289 ops/sec [1,215..1,320]	~ overlap (+1.4%)	794 ops/sec [726..823] → 808 ops/sec [745..866]	~ overlap (+1.7%)
async generator with await in body	5,156 ops/sec [4,511..5,682] → 5,373 ops/sec [5,134..6,019]	~ overlap (+4.2%)	6,161 ops/sec [5,984..6,564] → 6,137 ops/sec [5,614..6,817]	~ overlap (-0.4%)

atomics.js — Interp: 6 unch. · avg -0.6% · Bytecode: 6 unch. · avg -1.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
load and store Int32Array	68,062 ops/sec [67,513..74,886] → 69,138 ops/sec [64,783..86,753]	~ overlap (+1.6%)	146,040 ops/sec [137,793..149,094] → 143,138 ops/sec [136,739..146,011]	~ overlap (-2.0%)
read-modify-write Int32Array	49,946 ops/sec [48,974..51,094] → 48,551 ops/sec [48,215..59,188]	~ overlap (-2.8%)	99,476 ops/sec [96,818..107,124] → 98,845 ops/sec [95,309..104,464]	~ overlap (-0.6%)
compareExchange hit and miss	45,937 ops/sec [45,328..47,445] → 45,717 ops/sec [45,009..46,758]	~ overlap (-0.5%)	94,992 ops/sec [90,715..105,110] → 92,500 ops/sec [89,426..95,755]	~ overlap (-2.6%)
wait with zero timeout	114,361 ops/sec [112,932..114,883] → 113,834 ops/sec [112,817..114,289]	~ overlap (-0.5%)	241,694 ops/sec [232,355..252,195] → 231,841 ops/sec [222,440..237,431]	~ overlap (-4.1%)
waitAsync synchronous not-equal	82,475 ops/sec [80,994..100,091] → 82,070 ops/sec [80,810..92,639]	~ overlap (-0.5%)	145,197 ops/sec [132,269..150,876] → 147,189 ops/sec [145,171..151,165]	~ overlap (+1.4%)
notify with no waiters	114,211 ops/sec [109,926..119,044] → 112,813 ops/sec [111,557..117,190]	~ overlap (-1.2%)	226,942 ops/sec [216,361..234,580] → 226,599 ops/sec [225,302..232,430]	~ overlap (-0.2%)

base64.js — Interp: 10 unch. · avg +0.4% · Bytecode: 🔴 1, 9 unch. · avg -1.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
short ASCII (13 chars)	2,022 ops/sec [1,958..2,054] → 1,984 ops/sec [1,977..2,017]	~ overlap (-1.9%)	2,670 ops/sec [2,609..2,731] → 2,737 ops/sec [2,675..2,823]	~ overlap (+2.5%)
medium ASCII (450 chars)	73 ops/sec [72..74] → 72 ops/sec [70..73]	~ overlap (-1.5%)	98 ops/sec [92..100] → 96 ops/sec [94..100]	~ overlap (-1.5%)
Latin-1 characters	2,925 ops/sec [2,874..2,954] → 2,936 ops/sec [2,835..3,063]	~ overlap (+0.4%)	3,981 ops/sec [3,867..4,103] → 3,942 ops/sec [3,830..4,139]	~ overlap (-1.0%)
short base64 (20 chars)	1,453 ops/sec [1,437..1,575] → 1,480 ops/sec [1,462..1,493]	~ overlap (+1.8%)	1,975 ops/sec [1,963..2,016] → 1,965 ops/sec [1,872..2,136]	~ overlap (-0.5%)
medium base64 (600 chars)	57 ops/sec [57..58] → 59 ops/sec [58..67]	~ overlap (+2.7%)	77 ops/sec [75..87] → 79 ops/sec [78..80]	~ overlap (+2.7%)
Latin-1 output	2,178 ops/sec [2,086..2,236] → 2,121 ops/sec [2,052..2,125]	~ overlap (-2.6%)	2,831 ops/sec [2,691..2,935] → 2,900 ops/sec [2,869..2,941]	~ overlap (+2.4%)
forgiving (no padding)	3,124 ops/sec [3,060..3,207] → 3,131 ops/sec [2,940..3,651]	~ overlap (+0.2%)	4,231 ops/sec [4,134..4,600] → 4,148 ops/sec [4,058..4,277]	~ overlap (-1.9%)
with whitespace	1,455 ops/sec [1,428..1,495] → 1,464 ops/sec [1,454..1,491]	~ overlap (+0.6%)	2,035 ops/sec [1,954..2,158] → 1,890 ops/sec [1,843..1,922]	🔴 -7.1%
atob(btoa(short))	862 ops/sec [860..915] → 862 ops/sec [819..881]	~ overlap (-0.0%)	1,179 ops/sec [1,162..1,206] → 1,138 ops/sec [1,098..1,182]	~ overlap (-3.5%)
atob(btoa(medium))	32 ops/sec [30..34] → 34 ops/sec [33..38]	~ overlap (+4.5%)	44 ops/sec [43..44] → 43 ops/sec [42..45]	~ overlap (-1.8%)

classes.js — Interp: 🟢 3, 🔴 1, 27 unch. · avg +1.7% · Bytecode: 🟢 1, 🔴 3, 27 unch. · avg -0.7%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple class new	32,925 ops/sec [32,760..33,065] → 32,108 ops/sec [31,685..32,618]	🔴 -2.5%	62,762 ops/sec [60,769..63,911] → 65,763 ops/sec [63,630..69,260]	~ overlap (+4.8%)
class with defaults	25,795 ops/sec [25,195..25,980] → 26,013 ops/sec [25,803..26,073]	~ overlap (+0.8%)	43,920 ops/sec [42,462..47,194] → 44,712 ops/sec [43,387..45,385]	~ overlap (+1.8%)
50 instances via Array.from	1,160 ops/sec [1,142..1,170] → 1,167 ops/sec [1,152..1,169]	~ overlap (+0.6%)	1,726 ops/sec [1,670..1,868] → 1,747 ops/sec [1,625..1,791]	~ overlap (+1.2%)
instance method call	15,293 ops/sec [13,123..16,934] → 15,283 ops/sec [14,861..15,380]	~ overlap (-0.1%)	34,439 ops/sec [34,389..34,850] → 33,176 ops/sec [33,021..33,242]	🔴 -3.7%
static method call	25,685 ops/sec [25,548..25,797] → 26,142 ops/sec [25,673..26,361]	~ overlap (+1.8%)	72,328 ops/sec [70,016..76,385] → 70,434 ops/sec [66,204..71,306]	~ overlap (-2.6%)
single-level inheritance	13,407 ops/sec [13,026..15,965] → 13,299 ops/sec [12,974..13,459]	~ overlap (-0.8%)	24,441 ops/sec [22,924..24,912] → 24,263 ops/sec [23,453..24,511]	~ overlap (-0.7%)
two-level inheritance	11,814 ops/sec [11,745..11,925] → 11,752 ops/sec [11,497..12,044]	~ overlap (-0.5%)	18,836 ops/sec [18,143..19,005] → 18,217 ops/sec [17,363..19,357]	~ overlap (-3.3%)
private field access	16,320 ops/sec [16,242..16,472] → 16,405 ops/sec [16,168..18,366]	~ overlap (+0.5%)	14,764 ops/sec [13,778..16,017] → 14,790 ops/sec [14,208..14,981]	~ overlap (+0.2%)
private methods	17,986 ops/sec [17,845..18,274] → 18,364 ops/sec [18,043..19,077]	~ overlap (+2.1%)	15,146 ops/sec [14,538..15,263] → 15,402 ops/sec [14,923..16,947]	~ overlap (+1.7%)
getter/setter access	17,750 ops/sec [17,165..18,058] → 18,028 ops/sec [17,931..19,040]	~ overlap (+1.6%)	40,151 ops/sec [34,364..41,118] → 34,490 ops/sec [32,678..35,342]	~ overlap (-14.1%)
class decorator (identity)	26,815 ops/sec [26,222..27,191] → 27,171 ops/sec [26,970..28,823]	~ overlap (+1.3%)	37,979 ops/sec [37,459..38,642] → 38,127 ops/sec [37,962..38,284]	~ overlap (+0.4%)
class decorator (wrapping)	15,084 ops/sec [14,816..17,430] → 15,972 ops/sec [14,976..20,035]	~ overlap (+5.9%)	20,458 ops/sec [19,142..23,167] → 19,982 ops/sec [19,683..22,823]	~ overlap (-2.3%)
identity method decorator	19,304 ops/sec [18,803..19,754] → 20,322 ops/sec [20,009..23,570]	🟢 +5.3%	32,725 ops/sec [31,055..33,130] → 32,314 ops/sec [29,719..33,016]	~ overlap (-1.3%)
wrapping method decorator	15,540 ops/sec [15,353..15,641] → 18,126 ops/sec [15,770..19,824]	🟢 +16.6%	23,844 ops/sec [23,003..24,504] → 21,987 ops/sec [21,477..23,058]	~ overlap (-7.8%)
stacked method decorators (x3)	11,550 ops/sec [11,215..11,656] → 11,610 ops/sec [11,498..14,823]	~ overlap (+0.5%)	17,380 ops/sec [16,623..18,827] → 16,103 ops/sec [15,189..16,189]	🔴 -7.3%
identity field decorator	21,993 ops/sec [21,785..22,208] → 22,354 ops/sec [22,316..22,411]	🟢 +1.6%	28,004 ops/sec [27,495..30,869] → 28,521 ops/sec [28,331..28,922]	~ overlap (+1.8%)
field initializer decorator	18,440 ops/sec [18,153..18,665] → 19,296 ops/sec [18,597..19,877]	~ overlap (+4.6%)	26,580 ops/sec [26,358..27,393] → 26,064 ops/sec [24,633..28,287]	~ overlap (-1.9%)
getter decorator (identity)	17,565 ops/sec [17,251..19,457] → 17,561 ops/sec [17,359..18,173]	~ overlap (-0.0%)	18,765 ops/sec [18,204..21,303] → 19,148 ops/sec [19,037..20,996]	~ overlap (+2.0%)
setter decorator (identity)	14,282 ops/sec [14,150..16,094] → 14,537 ops/sec [14,458..14,687]	~ overlap (+1.8%)	14,690 ops/sec [14,297..14,957] → 15,466 ops/sec [14,930..15,780]	~ overlap (+5.3%)
static method decorator	21,079 ops/sec [20,477..21,150] → 21,023 ops/sec [20,392..25,474]	~ overlap (-0.3%)	32,648 ops/sec [32,049..32,717] → 34,269 ops/sec [33,356..36,704]	🟢 +5.0%
static field decorator	24,808 ops/sec [23,862..25,437] → 24,415 ops/sec [23,963..24,672]	~ overlap (-1.6%)	36,185 ops/sec [34,549..43,585] → 39,140 ops/sec [36,887..42,152]	~ overlap (+8.2%)
private method decorator	15,162 ops/sec [14,819..20,449] → 14,790 ops/sec [14,694..14,900]	~ overlap (-2.5%)	21,847 ops/sec [20,133..25,001] → 20,714 ops/sec [19,956..22,106]	~ overlap (-5.2%)
private field decorator	16,811 ops/sec [16,598..16,989] → 17,057 ops/sec [16,910..17,117]	~ overlap (+1.5%)	18,818 ops/sec [16,998..19,008] → 18,135 ops/sec [18,028..18,666]	~ overlap (-3.6%)
plain auto-accessor (no decorator)	31,241 ops/sec [28,054..35,022] → 28,985 ops/sec [28,325..29,088]	~ overlap (-7.2%)	36,978 ops/sec [36,694..37,755] → 36,945 ops/sec [36,744..37,370]	~ overlap (-0.1%)
auto-accessor with decorator	16,423 ops/sec [16,038..17,355] → 17,167 ops/sec [17,058..17,682]	~ overlap (+4.5%)	22,231 ops/sec [21,804..22,882] → 21,997 ops/sec [21,430..26,331]	~ overlap (-1.1%)
decorator writing metadata	13,848 ops/sec [13,688..15,384] → 14,693 ops/sec [14,529..14,819]	~ overlap (+6.1%)	19,999 ops/sec [19,509..20,575] → 20,417 ops/sec [19,013..23,378]	~ overlap (+2.1%)
static getter read	31,126 ops/sec [30,517..35,131] → 30,533 ops/sec [28,853..31,755]	~ overlap (-1.9%)	58,067 ops/sec [54,836..66,659] → 57,422 ops/sec [56,670..58,784]	~ overlap (-1.1%)
static getter/setter pair	22,600 ops/sec [22,511..22,699] → 23,354 ops/sec [21,862..25,688]	~ overlap (+3.3%)	44,746 ops/sec [44,013..47,844] → 41,278 ops/sec [39,661..42,628]	🔴 -7.7%
inherited static getter	18,982 ops/sec [18,749..19,440] → 20,630 ops/sec [18,995..23,507]	~ overlap (+8.7%)	35,439 ops/sec [34,842..36,117] → 37,563 ops/sec [35,870..39,893]	~ overlap (+6.0%)
inherited static setter	21,195 ops/sec [21,028..24,963] → 20,981 ops/sec [19,575..25,181]	~ overlap (-1.0%)	34,814 ops/sec [33,350..36,742] → 36,343 ops/sec [35,164..36,985]	~ overlap (+4.4%)
inherited static getter with this binding	16,309 ops/sec [16,228..16,615] → 16,400 ops/sec [16,217..16,430]	~ overlap (+0.6%)	29,892 ops/sec [28,009..30,183] → 29,110 ops/sec [28,673..29,808]	~ overlap (-2.6%)

closures.js — Interp: 🟢 1, 10 unch. · avg +2.3% · Bytecode: 🔴 1, 10 unch. · avg -1.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
closure over single variable	24,090 ops/sec [23,841..27,696] → 24,456 ops/sec [24,138..27,317]	~ overlap (+1.5%)	118,632 ops/sec [113,114..122,693] → 125,302 ops/sec [119,410..129,656]	~ overlap (+5.6%)
closure over multiple variables	28,119 ops/sec [28,015..28,932] → 28,473 ops/sec [27,490..29,252]	~ overlap (+1.3%)	122,328 ops/sec [118,782..128,335] → 122,565 ops/sec [116,756..124,613]	~ overlap (+0.2%)
nested closures	31,859 ops/sec [30,235..32,714] → 31,968 ops/sec [31,820..32,163]	~ overlap (+0.3%)	113,089 ops/sec [109,038..117,671] → 108,000 ops/sec [106,888..109,650]	~ overlap (-4.5%)
function as argument	23,171 ops/sec [16,751..23,956] → 23,691 ops/sec [22,881..29,525]	~ overlap (+2.2%)	112,325 ops/sec [109,630..115,148] → 105,744 ops/sec [99,125..107,705]	🔴 -5.9%
function returning function	29,227 ops/sec [28,868..29,565] → 30,687 ops/sec [29,042..31,202]	~ overlap (+5.0%)	128,857 ops/sec [126,836..131,070] → 124,422 ops/sec [118,578..135,999]	~ overlap (-3.4%)
compose two functions	18,605 ops/sec [18,501..18,984] → 19,617 ops/sec [19,009..24,689]	🟢 +5.4%	76,925 ops/sec [72,222..100,770] → 73,769 ops/sec [70,051..89,877]	~ overlap (-4.1%)
fn.call	38,614 ops/sec [38,375..38,870] → 39,656 ops/sec [38,842..43,951]	~ overlap (+2.7%)	110,477 ops/sec [104,931..114,157] → 108,726 ops/sec [105,892..117,022]	~ overlap (-1.6%)
fn.apply	32,254 ops/sec [31,364..32,372] → 32,428 ops/sec [32,157..33,100]	~ overlap (+0.5%)	93,351 ops/sec [90,873..111,272] → 91,915 ops/sec [89,984..94,881]	~ overlap (-1.5%)
fn.bind	33,362 ops/sec [31,563..35,755] → 34,199 ops/sec [31,394..36,699]	~ overlap (+2.5%)	124,466 ops/sec [119,532..134,715] → 125,522 ops/sec [119,437..131,412]	~ overlap (+0.8%)
recursive sum to 50	2,882 ops/sec [2,763..3,114] → 2,878 ops/sec [2,762..3,017]	~ overlap (-0.1%)	20,163 ops/sec [18,590..21,124] → 20,252 ops/sec [19,196..20,995]	~ overlap (+0.4%)
recursive tree traversal	4,528 ops/sec [4,492..4,593] → 4,704 ops/sec [4,547..5,816]	~ overlap (+3.9%)	15,532 ops/sec [14,008..17,735] → 15,591 ops/sec [15,478..15,965]	~ overlap (+0.4%)

collections.js — Interp: 12 unch. · avg +0.0% · Bytecode: 🟢 1, 🔴 1, 10 unch. · avg -0.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
add 50 elements	2,651 ops/sec [2,633..2,711] → 2,653 ops/sec [2,619..2,672]	~ overlap (+0.1%)	4,311 ops/sec [4,009..4,464] → 4,153 ops/sec [4,027..4,369]	~ overlap (-3.7%)
has lookup (50 elements)	45,825 ops/sec [44,750..46,704] → 45,602 ops/sec [43,811..46,678]	~ overlap (-0.5%)	112,180 ops/sec [104,382..118,713] → 105,282 ops/sec [102,804..111,372]	~ overlap (-6.1%)
delete elements	13,179 ops/sec [12,398..13,459] → 12,885 ops/sec [12,658..16,751]	~ overlap (-2.2%)	21,543 ops/sec [21,244..24,954] → 20,964 ops/sec [19,992..21,378]	~ overlap (-2.7%)
forEach iteration	3,575 ops/sec [3,400..4,544] → 3,544 ops/sec [3,473..3,663]	~ overlap (-0.9%)	7,431 ops/sec [7,329..7,615] → 7,152 ops/sec [6,929..7,212]	🔴 -3.8%
spread to array	10,141 ops/sec [10,123..10,183] → 10,332 ops/sec [9,764..11,890]	~ overlap (+1.9%)	62,450 ops/sec [61,279..65,883] → 60,960 ops/sec [57,847..73,191]	~ overlap (-2.4%)
deduplicate array	9,961 ops/sec [9,420..12,023] → 10,055 ops/sec [9,811..10,087]	~ overlap (+0.9%)	19,927 ops/sec [18,806..20,118] → 19,362 ops/sec [18,309..20,910]	~ overlap (-2.8%)
set 50 entries	1,965 ops/sec [1,957..1,974] → 1,987 ops/sec [1,960..2,409]	~ overlap (+1.1%)	3,334 ops/sec [3,233..3,361] → 3,385 ops/sec [3,238..3,440]	~ overlap (+1.5%)
get lookup (50 entries)	47,246 ops/sec [46,562..65,335] → 47,267 ops/sec [46,762..47,597]	~ overlap (+0.0%)	96,828 ops/sec [95,165..98,980] → 95,009 ops/sec [94,028..107,256]	~ overlap (-1.9%)
has check	61,016 ops/sec [59,620..62,322] → 59,794 ops/sec [59,427..60,805]	~ overlap (-2.0%)	124,863 ops/sec [118,418..133,696] → 133,506 ops/sec [126,221..153,461]	~ overlap (+6.9%)
delete entries	12,184 ops/sec [11,318..12,247] → 12,390 ops/sec [11,794..12,563]	~ overlap (+1.7%)	18,750 ops/sec [17,657..20,509] → 19,978 ops/sec [19,070..20,847]	~ overlap (+6.5%)
forEach iteration	3,426 ops/sec [3,375..4,198] → 3,434 ops/sec [3,429..3,554]	~ overlap (+0.2%)	7,472 ops/sec [7,345..7,752] → 8,031 ops/sec [7,843..8,578]	🟢 +7.5%
keys/values/entries	2,932 ops/sec [2,657..3,279] → 2,937 ops/sec [2,884..3,914]	~ overlap (+0.2%)	12,152 ops/sec [11,859..13,129] → 11,698 ops/sec [11,213..14,640]	~ overlap (-3.7%)

csv.js — Interp: 13 unch. · avg +2.3% · Bytecode: 🔴 1, 12 unch. · avg -4.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple 3-column CSV	39,470 ops/sec [37,309..47,188] → 38,618 ops/sec [37,572..39,362]	~ overlap (-2.2%)	46,571 ops/sec [45,238..52,240] → 45,305 ops/sec [44,600..49,181]	~ overlap (-2.7%)
parse 10-row CSV	11,126 ops/sec [10,970..11,920] → 11,401 ops/sec [11,147..12,137]	~ overlap (+2.5%)	14,996 ops/sec [14,074..15,383] → 13,769 ops/sec [13,161..14,673]	~ overlap (-8.2%)
parse 100-row CSV	1,766 ops/sec [1,744..2,108] → 1,829 ops/sec [1,822..1,893]	~ overlap (+3.5%)	2,377 ops/sec [2,308..2,466] → 2,246 ops/sec [2,153..2,618]	~ overlap (-5.5%)
parse CSV with quoted fields	56,139 ops/sec [55,750..56,946] → 57,570 ops/sec [55,649..61,142]	~ overlap (+2.5%)	74,175 ops/sec [70,741..82,297] → 67,055 ops/sec [66,228..67,952]	🔴 -9.6%
parse without headers (array of arrays)	5,350 ops/sec [5,265..5,415] → 5,384 ops/sec [5,364..6,944]	~ overlap (+0.6%)	6,616 ops/sec [6,328..7,465] → 6,499 ops/sec [6,118..7,290]	~ overlap (-1.8%)
parse with semicolon delimiter	8,271 ops/sec [8,024..8,307] → 8,963 ops/sec [8,068..9,785]	~ overlap (+8.4%)	10,379 ops/sec [9,951..11,369] → 9,814 ops/sec [9,600..10,046]	~ overlap (-5.4%)
stringify array of objects	43,199 ops/sec [40,023..50,609] → 40,697 ops/sec [39,681..41,728]	~ overlap (-5.8%)	56,462 ops/sec [55,247..58,739] → 52,574 ops/sec [49,734..74,744]	~ overlap (-6.9%)
stringify array of arrays	17,875 ops/sec [17,707..21,136] → 18,252 ops/sec [17,241..18,575]	~ overlap (+2.1%)	22,300 ops/sec [20,924..23,536] → 20,779 ops/sec [19,813..23,573]	~ overlap (-6.8%)
stringify with values needing escaping	22,213 ops/sec [21,730..22,627] → 22,858 ops/sec [22,179..26,285]	~ overlap (+2.9%)	30,694 ops/sec [29,506..32,575] → 28,513 ops/sec [26,529..30,990]	~ overlap (-7.1%)
reviver converts numbers	521 ops/sec [520..524] → 525 ops/sec [520..539]	~ overlap (+0.7%)	855 ops/sec [731..913] → 770 ops/sec [744..795]	~ overlap (-10.0%)
reviver filters empty to null	6,859 ops/sec [6,552..7,134] → 7,853 ops/sec [6,733..8,383]	~ overlap (+14.5%)	11,986 ops/sec [11,760..16,036] → 11,599 ops/sec [11,186..12,893]	~ overlap (-3.2%)
parse then stringify	6,771 ops/sec [6,563..6,815] → 6,927 ops/sec [6,640..7,448]	~ overlap (+2.3%)	7,852 ops/sec [7,475..8,057] → 8,268 ops/sec [7,843..8,392]	~ overlap (+5.3%)
stringify then parse	6,616 ops/sec [6,413..7,556] → 6,476 ops/sec [6,427..6,621]	~ overlap (-2.1%)	7,828 ops/sec [7,586..8,223] → 8,222 ops/sec [7,555..8,498]	~ overlap (+5.0%)

destructuring.js — Interp: 🟢 2, 20 unch. · avg -0.0% · Bytecode: 🟢 1, 🔴 1, 20 unch. · avg +1.5%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple array destructuring	50,356 ops/sec [49,879..52,229] → 51,160 ops/sec [49,895..52,522]	~ overlap (+1.6%)	89,704 ops/sec [87,720..92,372] → 93,932 ops/sec [91,363..98,252]	~ overlap (+4.7%)
with rest element	43,891 ops/sec [42,472..47,828] → 44,218 ops/sec [43,185..44,863]	~ overlap (+0.7%)	69,602 ops/sec [65,812..74,919] → 71,925 ops/sec [70,831..74,308]	~ overlap (+3.3%)
with defaults	54,187 ops/sec [52,685..54,902] → 54,490 ops/sec [52,748..60,568]	~ overlap (+0.6%)	96,177 ops/sec [92,956..102,636] → 99,805 ops/sec [94,925..120,605]	~ overlap (+3.8%)
skip elements	59,994 ops/sec [59,474..60,173] → 61,013 ops/sec [59,368..65,388]	~ overlap (+1.7%)	100,309 ops/sec [95,541..104,332] → 98,101 ops/sec [96,068..99,923]	~ overlap (-2.2%)
nested array destructuring	24,973 ops/sec [24,165..30,411] → 25,055 ops/sec [24,492..25,819]	~ overlap (+0.3%)	36,969 ops/sec [35,907..48,942] → 34,911 ops/sec [33,477..35,590]	🔴 -5.6%
swap variables	69,879 ops/sec [69,108..70,832] → 70,509 ops/sec [69,775..71,135]	~ overlap (+0.9%)	165,616 ops/sec [148,916..171,339] → 156,825 ops/sec [152,769..173,734]	~ overlap (-5.3%)
simple object destructuring	62,812 ops/sec [62,241..62,872] → 62,052 ops/sec [61,661..62,306]	~ overlap (-1.2%)	118,829 ops/sec [111,696..123,037] → 114,856 ops/sec [112,744..124,742]	~ overlap (-3.3%)
with defaults	66,377 ops/sec [65,960..71,147] → 66,166 ops/sec [65,992..72,964]	~ overlap (-0.3%)	169,933 ops/sec [168,543..171,301] → 166,756 ops/sec [156,083..179,214]	~ overlap (-1.9%)
with renaming	70,482 ops/sec [68,681..73,866] → 70,521 ops/sec [70,357..70,900]	~ overlap (+0.1%)	132,258 ops/sec [127,906..137,259] → 127,682 ops/sec [125,926..131,823]	~ overlap (-3.5%)
nested object destructuring	41,691 ops/sec [40,657..42,775] → 38,863 ops/sec [38,375..41,006]	~ overlap (-6.8%)	61,834 ops/sec [60,315..78,297] → 72,277 ops/sec [63,838..73,799]	~ overlap (+16.9%)
rest properties	36,323 ops/sec [35,495..37,525] → 34,846 ops/sec [34,462..35,875]	~ overlap (-4.1%)	49,002 ops/sec [48,581..51,987] → 51,528 ops/sec [49,759..58,246]	~ overlap (+5.2%)
object parameter	21,958 ops/sec [21,760..22,051] → 21,744 ops/sec [20,728..22,566]	~ overlap (-1.0%)	56,423 ops/sec [53,900..59,804] → 56,611 ops/sec [54,043..70,789]	~ overlap (+0.3%)
array parameter	24,536 ops/sec [24,447..25,934] → 24,950 ops/sec [24,623..26,108]	~ overlap (+1.7%)	52,289 ops/sec [51,151..56,795] → 52,104 ops/sec [50,543..53,356]	~ overlap (-0.4%)
mixed destructuring in map	5,790 ops/sec [5,595..5,866] → 5,867 ops/sec [5,771..6,029]	~ overlap (+1.3%)	12,342 ops/sec [11,810..13,438] → 12,529 ops/sec [11,574..13,044]	~ overlap (+1.5%)
forEach with array destructuring	11,343 ops/sec [11,121..11,479] → 11,134 ops/sec [10,504..11,444]	~ overlap (-1.8%)	19,730 ops/sec [19,018..20,141] → 19,206 ops/sec [18,675..19,700]	~ overlap (-2.7%)
map with array destructuring	12,462 ops/sec [11,816..12,945] → 11,828 ops/sec [11,247..12,072]	~ overlap (-5.1%)	16,959 ops/sec [15,050..17,441] → 16,034 ops/sec [15,438..16,682]	~ overlap (-5.5%)
filter with array destructuring	12,897 ops/sec [12,426..13,473] → 12,676 ops/sec [12,432..12,777]	~ overlap (-1.7%)	17,674 ops/sec [16,894..18,227] → 17,592 ops/sec [16,988..18,412]	~ overlap (-0.5%)
reduce with array destructuring	13,940 ops/sec [13,741..14,742] → 14,136 ops/sec [13,539..14,341]	~ overlap (+1.4%)	18,171 ops/sec [17,983..18,423] → 18,931 ops/sec [18,126..19,850]	~ overlap (+4.2%)
map with object destructuring	13,904 ops/sec [13,792..14,007] → 14,418 ops/sec [14,080..14,576]	🟢 +3.7%	21,791 ops/sec [21,180..24,878] → 23,612 ops/sec [22,464..23,918]	~ overlap (+8.4%)
map with nested destructuring	11,473 ops/sec [11,391..11,495] → 11,943 ops/sec [11,741..12,132]	🟢 +4.1%	21,471 ops/sec [21,344..21,856] → 22,991 ops/sec [22,178..24,160]	🟢 +7.1%
map with rest in destructuring	6,749 ops/sec [6,467..7,515] → 6,835 ops/sec [6,690..6,931]	~ overlap (+1.3%)	8,816 ops/sec [8,363..10,476] → 8,645 ops/sec [8,351..9,078]	~ overlap (-1.9%)
map with defaults in destructuring	7,832 ops/sec [7,600..8,345] → 8,026 ops/sec [7,842..8,179]	~ overlap (+2.5%)	18,827 ops/sec [18,229..19,680] → 20,816 ops/sec [19,556..21,501]	~ overlap (+10.6%)

fibonacci.js — Interp: 8 unch. · avg +1.7% · Bytecode: 8 unch. · avg -0.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
recursive fib(15)	80 ops/sec [78..86] → 83 ops/sec [83..84]	~ overlap (+3.8%)	534 ops/sec [511..571] → 528 ops/sec [507..614]	~ overlap (-1.0%)
recursive fib(20)	8 ops/sec [7..8] → 8 ops/sec [7..8]	~ overlap (-3.0%)	51 ops/sec [49..56] → 48 ops/sec [46..55]	~ overlap (-5.0%)
recursive fib(15) typed	81 ops/sec [80..84] → 83 ops/sec [74..100]	~ overlap (+2.1%)	565 ops/sec [543..590] → 563 ops/sec [525..598]	~ overlap (-0.4%)
recursive fib(20) typed	8 ops/sec [7..8] → 8 ops/sec [8..8]	~ overlap (+2.2%)	49 ops/sec [46..49] → 46 ops/sec [45..56]	~ overlap (-5.5%)
iterative fib(20) via reduce	3,829 ops/sec [3,797..3,875] → 3,917 ops/sec [3,724..4,453]	~ overlap (+2.3%)	7,120 ops/sec [6,621..7,394] → 6,976 ops/sec [6,593..7,092]	~ overlap (-2.0%)
iterator fib(20)	1,873 ops/sec [1,861..1,944] → 1,917 ops/sec [1,895..1,991]	~ overlap (+2.3%)	5,780 ops/sec [5,635..5,892] → 5,790 ops/sec [5,432..5,854]	~ overlap (+0.2%)
iterator fib(20) via Iterator.from + take	1,938 ops/sec [1,925..2,013] → 2,039 ops/sec [2,006..2,079]	~ overlap (+5.2%)	3,505 ops/sec [3,433..3,752] → 3,819 ops/sec [3,466..4,412]	~ overlap (+9.0%)
iterator fib(20) last value via reduce	1,759 ops/sec [1,698..1,781] → 1,731 ops/sec [1,690..1,753]	~ overlap (-1.6%)	2,809 ops/sec [2,679..3,043] → 2,923 ops/sec [2,835..3,152]	~ overlap (+4.1%)

float16array.js — Interp: 🟢 2, 🔴 1, 29 unch. · avg +0.3% · Bytecode: 🟢 3, 29 unch. · avg +2.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
new Float16Array(0)	101,810 ops/sec [101,005..102,204] → 99,921 ops/sec [99,295..101,628]	~ overlap (-1.9%)	169,911 ops/sec [162,773..173,008] → 167,881 ops/sec [159,724..193,007]	~ overlap (-1.2%)
new Float16Array(100)	98,265 ops/sec [98,001..98,970] → 95,639 ops/sec [94,743..100,497]	~ overlap (-2.7%)	161,043 ops/sec [151,671..169,006] → 157,776 ops/sec [151,845..165,231]	~ overlap (-2.0%)
new Float16Array(1000)	85,338 ops/sec [82,372..86,281] → 84,987 ops/sec [84,651..86,116]	~ overlap (-0.4%)	130,995 ops/sec [129,977..134,609] → 136,777 ops/sec [129,869..142,391]	~ overlap (+4.4%)
Float16Array.from([...100])	1,225 ops/sec [1,203..1,239] → 1,272 ops/sec [1,212..1,287]	~ overlap (+3.8%)	1,611 ops/sec [1,513..1,675] → 1,658 ops/sec [1,625..1,984]	~ overlap (+2.9%)
Float16Array.of(1.5, 2.5, 3.5, 4.5, 5.5)	63,627 ops/sec [59,135..89,938] → 59,859 ops/sec [58,394..62,675]	~ overlap (-5.9%)	92,927 ops/sec [92,558..93,379] → 96,285 ops/sec [90,278..112,371]	~ overlap (+3.6%)
new Float16Array(float64Array)	25,947 ops/sec [24,904..26,170] → 25,275 ops/sec [25,055..25,584]	~ overlap (-2.6%)	33,308 ops/sec [29,999..37,401] → 32,363 ops/sec [30,938..33,645]	~ overlap (-2.8%)
sequential write 100 elements	884 ops/sec [874..911] → 900 ops/sec [862..909]	~ overlap (+1.8%)	7,939 ops/sec [7,599..8,419] → 7,364 ops/sec [7,225..10,108]	~ overlap (-7.2%)
sequential read 100 elements	1,017 ops/sec [1,011..1,022] → 1,034 ops/sec [972..1,069]	~ overlap (+1.6%)	10,027 ops/sec [9,399..10,174] → 9,784 ops/sec [9,592..9,904]	~ overlap (-2.4%)
write special values (NaN, Inf, -0)	44,586 ops/sec [44,495..44,780] → 45,120 ops/sec [42,960..45,960]	~ overlap (+1.2%)	205,435 ops/sec [203,391..232,430] → 213,336 ops/sec [209,567..219,106]	~ overlap (+3.8%)
Float16Array write	898 ops/sec [897..905] → 910 ops/sec [879..969]	~ overlap (+1.3%)	7,639 ops/sec [7,436..8,023] → 7,823 ops/sec [7,523..7,883]	~ overlap (+2.4%)
Float32Array write	888 ops/sec [879..894] → 909 ops/sec [885..954]	~ overlap (+2.4%)	7,768 ops/sec [7,613..8,023] → 7,666 ops/sec [7,539..8,073]	~ overlap (-1.3%)
Float64Array write	860 ops/sec [750..886] → 909 ops/sec [864..936]	~ overlap (+5.7%)	7,436 ops/sec [7,265..7,613] → 7,635 ops/sec [7,400..7,801]	~ overlap (+2.7%)
Float16Array read	984 ops/sec [977..1,014] → 1,003 ops/sec [933..1,017]	~ overlap (+2.0%)	9,703 ops/sec [9,303..10,744] → 9,616 ops/sec [9,499..10,869]	~ overlap (-0.9%)
Float32Array read	1,021 ops/sec [1,016..1,022] → 1,016 ops/sec [991..1,135]	~ overlap (-0.5%)	9,574 ops/sec [9,492..9,865] → 9,384 ops/sec [8,946..9,951]	~ overlap (-2.0%)
Float64Array read	1,041 ops/sec [1,021..1,047] → 1,023 ops/sec [981..1,088]	~ overlap (-1.7%)	9,430 ops/sec [8,974..9,737] → 9,462 ops/sec [9,056..9,965]	~ overlap (+0.3%)
fill(1.5)	6,720 ops/sec [6,678..9,337] → 6,591 ops/sec [6,576..6,613]	🔴 -1.9%	8,459 ops/sec [7,862..8,914] → 8,682 ops/sec [8,223..8,859]	~ overlap (+2.6%)
slice()	51,695 ops/sec [51,520..52,151] → 53,790 ops/sec [53,540..54,028]	🟢 +4.1%	78,039 ops/sec [76,164..78,575] → 90,363 ops/sec [79,440..96,471]	🟢 +15.8%
map(x => x * 2)	1,954 ops/sec [1,849..2,064] → 1,993 ops/sec [1,987..2,005]	~ overlap (+2.0%)	2,455 ops/sec [2,357..2,476] → 2,654 ops/sec [2,562..2,914]	🟢 +8.1%
filter(x => x > 25)	1,936 ops/sec [1,853..2,106] → 1,990 ops/sec [1,990..2,010]	~ overlap (+2.8%)	2,478 ops/sec [2,378..2,532] → 2,537 ops/sec [2,458..2,580]	~ overlap (+2.4%)
reduce (sum)	1,870 ops/sec [1,803..1,923] → 1,866 ops/sec [1,843..1,873]	~ overlap (-0.2%)	2,275 ops/sec [2,220..2,306] → 2,279 ops/sec [2,082..2,613]	~ overlap (+0.2%)
sort()	21,849 ops/sec [21,742..22,130] → 22,078 ops/sec [21,925..22,241]	~ overlap (+1.0%)	27,153 ops/sec [27,088..28,470] → 28,283 ops/sec [26,642..29,497]	~ overlap (+4.2%)
indexOf()	26,072 ops/sec [25,404..26,290] → 27,334 ops/sec [26,420..29,931]	🟢 +4.8%	32,957 ops/sec [32,007..33,891] → 37,339 ops/sec [32,981..43,611]	~ overlap (+13.3%)
reverse()	28,492 ops/sec [28,139..28,949] → 28,733 ops/sec [27,919..29,724]	~ overlap (+0.8%)	35,709 ops/sec [34,475..36,388] → 38,496 ops/sec [37,648..39,812]	🟢 +7.8%
toReversed()	25,864 ops/sec [25,486..25,974] → 25,280 ops/sec [24,960..27,356]	~ overlap (-2.3%)	34,906 ops/sec [32,493..36,271] → 31,488 ops/sec [30,234..35,830]	~ overlap (-9.8%)
toSorted()	13,156 ops/sec [13,109..14,004] → 13,275 ops/sec [13,191..13,290]	~ overlap (+0.9%)	16,218 ops/sec [15,777..16,537] → 15,984 ops/sec [15,092..17,529]	~ overlap (-1.4%)
create view over existing buffer	119,752 ops/sec [118,526..120,310] → 119,874 ops/sec [119,277..123,346]	~ overlap (+0.1%)	205,563 ops/sec [203,090..215,883] → 219,674 ops/sec [201,007..225,956]	~ overlap (+6.9%)
subarray()	56,962 ops/sec [56,062..57,191] → 56,217 ops/sec [55,933..58,064]	~ overlap (-1.3%)	95,233 ops/sec [89,135..100,165] → 94,635 ops/sec [92,338..98,761]	~ overlap (-0.6%)
set() from array	66,473 ops/sec [63,453..70,043] → 65,536 ops/sec [65,107..66,083]	~ overlap (-1.4%)	95,582 ops/sec [93,885..103,335] → 97,078 ops/sec [96,594..98,729]	~ overlap (+1.6%)
for-of loop	1,360 ops/sec [1,325..1,466] → 1,350 ops/sec [1,312..1,382]	~ overlap (-0.7%)	11,654 ops/sec [11,061..12,173] → 12,159 ops/sec [11,294..13,375]	~ overlap (+4.3%)
spread into array	5,654 ops/sec [5,395..6,852] → 5,567 ops/sec [5,371..5,623]	~ overlap (-1.5%)	21,733 ops/sec [20,984..23,177] → 23,569 ops/sec [20,986..26,213]	~ overlap (+8.4%)
f16round(1.337)	142,182 ops/sec [137,219..151,648] → 138,468 ops/sec [136,928..141,777]	~ overlap (-2.6%)	269,941 ops/sec [253,658..277,255] → 259,383 ops/sec [236,647..288,216]	~ overlap (-3.9%)
f16round over 100 values	867 ops/sec [858..891] → 862 ops/sec [849..877]	~ overlap (-0.5%)	3,639 ops/sec [3,492..3,701] → 3,722 ops/sec [3,524..3,825]	~ overlap (+2.3%)

for-in/for-in.js — Interp: 🔴 1, 2 unch. · avg -1.1% · Bytecode: 🟢 1, 2 unch. · avg +5.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for...in over 50 own keys	2,436 ops/sec [2,380..2,462] → 2,434 ops/sec [2,347..2,445]	~ overlap (-0.1%)	4,379 ops/sec [4,261..4,548] → 4,703 ops/sec [4,305..4,803]	~ overlap (+7.4%)
for...in over an 8-level chain of 50 shared keys	1,636 ops/sec [1,629..1,641] → 1,627 ops/sec [1,607..1,636]	~ overlap (-0.6%)	2,601 ops/sec [2,549..2,644] → 2,821 ops/sec [2,685..2,886]	🟢 +8.4%
for...in over a 16-level chain of 100 shared keys	634 ops/sec [623..643] → 617 ops/sec [590..618]	🔴 -2.8%	880 ops/sec [864..900] → 874 ops/sec [838..885]	~ overlap (-0.6%)

for-of.js — Interp: 🟢 1, 🔴 1, 5 unch. · avg +1.3% · Bytecode: 🟢 3, 4 unch. · avg +8.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for...of with 10-element array	11,541 ops/sec [11,411..11,759] → 11,172 ops/sec [10,851..11,391]	🔴 -3.2%	102,109 ops/sec [100,802..103,066] → 108,342 ops/sec [102,247..111,598]	~ overlap (+6.1%)
for...of with 100-element array	1,301 ops/sec [1,288..1,329] → 1,397 ops/sec [1,325..1,569]	~ overlap (+7.4%)	15,694 ops/sec [15,224..16,118] → 16,617 ops/sec [15,326..18,273]	~ overlap (+5.9%)
for...of with string (10 chars)	8,302 ops/sec [8,120..8,907] → 8,401 ops/sec [8,272..8,532]	~ overlap (+1.2%)	27,327 ops/sec [25,938..27,673] → 27,557 ops/sec [27,127..28,035]	~ overlap (+0.8%)
for...of with Set (10 elements)	11,995 ops/sec [11,959..12,027] → 12,176 ops/sec [12,145..12,245]	🟢 +1.5%	151,429 ops/sec [145,360..183,289] → 160,543 ops/sec [157,859..174,639]	~ overlap (+6.0%)
for...of with Map entries (10 entries)	6,276 ops/sec [5,885..6,858] → 6,326 ops/sec [6,199..7,588]	~ overlap (+0.8%)	13,656 ops/sec [13,261..13,980] → 15,038 ops/sec [14,877..15,604]	🟢 +10.1%
for...of with destructuring	6,742 ops/sec [6,658..6,927] → 6,847 ops/sec [6,822..6,891]	~ overlap (+1.6%)	16,412 ops/sec [16,304..16,834] → 18,555 ops/sec [18,071..19,183]	🟢 +13.1%
for-await-of with sync array	7,640 ops/sec [7,521..7,749] → 7,618 ops/sec [7,585..7,668]	~ overlap (-0.3%)	2,155 ops/sec [2,111..2,185] → 2,455 ops/sec [2,252..2,964]	🟢 +13.9%

generators.js — Interp: 4 unch. · avg -1.1% · Bytecode: 4 unch. · avg -1.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
manual next over object generator	596 ops/sec [559..601] → 597 ops/sec [580..601]	~ overlap (+0.2%)	1,223 ops/sec [1,132..1,290] → 1,206 ops/sec [1,187..1,237]	~ overlap (-1.4%)
for...of over object generator	814 ops/sec [797..855] → 851 ops/sec [754..921]	~ overlap (+4.6%)	1,799 ops/sec [1,734..1,829] → 1,750 ops/sec [1,694..1,776]	~ overlap (-2.7%)
yield delegation	834 ops/sec [822..877] → 762 ops/sec [756..864]	~ overlap (-8.6%)	1,763 ops/sec [1,687..1,862] → 1,701 ops/sec [1,589..1,748]	~ overlap (-3.5%)
class generator method	833 ops/sec [828..939] → 826 ops/sec [767..887]	~ overlap (-0.7%)	1,729 ops/sec [1,701..1,803] → 1,767 ops/sec [1,601..1,891]	~ overlap (+2.2%)

intl.js — Interp: 🟢 1, 5 unch. · avg -1.2% · Bytecode: 6 unch. · avg +0.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
format decimal	21,254 ops/sec [20,430..22,163] → 20,987 ops/sec [20,468..21,703]	~ overlap (-1.3%)	33,257 ops/sec [32,118..33,710] → 35,664 ops/sec [32,334..37,330]	~ overlap (+7.2%)
format currency	17,247 ops/sec [16,860..18,393] → 16,927 ops/sec [16,792..18,781]	~ overlap (-1.9%)	28,042 ops/sec [27,861..30,819] → 27,684 ops/sec [27,126..28,889]	~ overlap (-1.3%)
format UTC date	8,462 ops/sec [8,410..8,582] → 8,328 ops/sec [8,178..8,525]	~ overlap (-1.6%)	11,886 ops/sec [11,596..12,273] → 11,477 ops/sec [10,763..11,744]	~ overlap (-3.4%)
formatRange UTC dates	2,627 ops/sec [2,606..2,639] → 2,479 ops/sec [2,007..3,300]	~ overlap (-5.6%)	3,645 ops/sec [3,604..3,812] → 3,575 ops/sec [3,510..3,924]	~ overlap (-1.9%)
compare numeric strings	85,098 ops/sec [83,801..85,774] → 86,221 ops/sec [85,941..87,232]	🟢 +1.3%	129,400 ops/sec [125,081..133,658] → 125,025 ops/sec [119,541..135,212]	~ overlap (-3.4%)
sort short string list	14,562 ops/sec [14,425..14,640] → 14,805 ops/sec [14,617..14,904]	~ overlap (+1.7%)	19,989 ops/sec [17,712..21,352] → 20,698 ops/sec [19,599..21,075]	~ overlap (+3.5%)

iterators.js — Interp: 🟢 4, 🔴 6, 32 unch. · avg -0.9% · Bytecode: 🟢 34, 8 unch. · avg +15.6%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Iterator.from({next}).toArray() — 20 elements	2,627 ops/sec [2,611..2,634] → 3,144 ops/sec [3,014..3,430]	🟢 +19.7%	5,296 ops/sec [5,180..5,412] → 6,256 ops/sec [6,083..6,506]	🟢 +18.1%
Iterator.from({next}).toArray() — 50 elements	1,137 ops/sec [1,131..1,142] → 1,267 ops/sec [1,223..1,336]	🟢 +11.4%	2,274 ops/sec [2,245..2,301] → 2,645 ops/sec [2,538..2,751]	🟢 +16.3%
spread pre-wrapped iterator — 20 elements	2,653 ops/sec [2,619..2,661] → 2,640 ops/sec [2,553..2,732]	~ overlap (-0.5%)	5,617 ops/sec [5,562..5,674] → 6,408 ops/sec [6,208..6,789]	🟢 +14.1%
Iterator.from({next}).forEach — 50 elements	852 ops/sec [846..902] → 908 ops/sec [855..917]	~ overlap (+6.7%)	1,617 ops/sec [1,549..1,632] → 1,921 ops/sec [1,834..1,962]	🟢 +18.8%
Iterator.from({next}).reduce — 50 elements	946 ops/sec [920..966] → 951 ops/sec [945..963]	~ overlap (+0.5%)	1,609 ops/sec [1,572..1,653] → 1,743 ops/sec [1,665..1,976]	🟢 +8.3%
wrap array iterator	12,747 ops/sec [12,399..12,969] → 12,654 ops/sec [12,407..14,560]	~ overlap (-0.7%)	16,964 ops/sec [16,729..17,860] → 19,954 ops/sec [19,757..20,671]	🟢 +17.6%
wrap plain {next()} object	2,013 ops/sec [1,997..2,063] → 2,061 ops/sec [2,041..2,086]	~ overlap (+2.3%)	3,691 ops/sec [3,667..4,187] → 4,500 ops/sec [4,407..5,387]	🟢 +21.9%
map + toArray (50 elements)	692 ops/sec [685..692] → 701 ops/sec [694..708]	🟢 +1.3%	1,048 ops/sec [1,034..1,068] → 1,257 ops/sec [1,206..1,342]	🟢 +20.0%
filter + toArray (50 elements)	768 ops/sec [727..872] → 739 ops/sec [735..903]	~ overlap (-3.7%)	1,164 ops/sec [1,142..1,189] → 1,370 ops/sec [1,309..1,383]	🟢 +17.7%
take(10) + toArray (50 element source)	3,873 ops/sec [3,693..3,912] → 3,767 ops/sec [3,693..4,014]	~ overlap (-2.7%)	5,733 ops/sec [5,630..6,645] → 6,644 ops/sec [6,417..7,183]	~ overlap (+15.9%)
drop(40) + toArray (50 element source)	1,027 ops/sec [1,004..1,062] → 1,022 ops/sec [1,004..1,025]	~ overlap (-0.4%)	1,846 ops/sec [1,648..1,947] → 1,864 ops/sec [1,640..1,932]	~ overlap (+1.0%)
chained map + filter + take (100 element source)	1,091 ops/sec [1,075..1,185] → 1,084 ops/sec [1,044..1,305]	~ overlap (-0.6%)	1,548 ops/sec [1,509..1,650] → 1,835 ops/sec [1,768..1,878]	🟢 +18.6%
some + every (50 elements)	538 ops/sec [530..557] → 532 ops/sec [524..544]	~ overlap (-1.2%)	937 ops/sec [927..1,000] → 1,050 ops/sec [1,015..1,079]	🟢 +12.1%
find (50 elements)	1,190 ops/sec [1,131..1,403] → 1,178 ops/sec [1,141..1,184]	~ overlap (-1.0%)	2,100 ops/sec [1,953..2,356] → 2,307 ops/sec [2,269..2,398]	~ overlap (+9.8%)
concat 2 arrays (10 + 10 elements)	5,366 ops/sec [5,171..6,150] → 5,057 ops/sec [5,038..5,810]	~ overlap (-5.8%)	6,040 ops/sec [6,012..6,201] → 7,354 ops/sec [7,058..7,463]	🟢 +21.8%
concat 5 arrays (10 elements each)	2,327 ops/sec [2,203..2,405] → 2,149 ops/sec [2,127..2,712]	~ overlap (-7.7%)	2,681 ops/sec [2,610..2,849] → 3,137 ops/sec [3,073..3,368]	🟢 +17.0%
concat 2 arrays (20 + 20 elements)	2,892 ops/sec [2,868..2,942] → 2,880 ops/sec [2,725..3,099]	~ overlap (-0.4%)	3,366 ops/sec [3,272..3,430] → 3,812 ops/sec [3,594..4,067]	🟢 +13.2%
concat + filter + toArray (20 + 20 elements)	1,311 ops/sec [1,277..1,777] → 1,234 ops/sec [1,223..1,252]	🔴 -5.8%	1,526 ops/sec [1,487..1,555] → 1,823 ops/sec [1,757..1,898]	🟢 +19.4%
concat + map + take (20 + 20 elements, take 10)	3,091 ops/sec [3,073..3,921] → 2,987 ops/sec [2,923..3,025]	🔴 -3.4%	3,734 ops/sec [3,672..3,780] → 4,318 ops/sec [4,252..4,365]	🟢 +15.6%
concat Sets (15 + 15 elements)	3,926 ops/sec [3,844..4,302] → 3,760 ops/sec [3,724..3,804]	🔴 -4.2%	4,803 ops/sec [4,462..5,369] → 5,501 ops/sec [4,928..6,241]	~ overlap (+14.5%)
concat boxed strings (13 + 13 characters)	3,976 ops/sec [3,921..3,998] → 4,004 ops/sec [3,823..4,524]	~ overlap (+0.7%)	4,915 ops/sec [4,562..4,972] → 5,610 ops/sec [5,459..5,829]	🟢 +14.1%
zip 2 arrays (10 + 10 elements)	9,556 ops/sec [9,188..9,585] → 9,101 ops/sec [9,084..9,152]	🔴 -4.8%	11,190 ops/sec [11,114..11,690] → 12,959 ops/sec [12,525..13,604]	🟢 +15.8%
zip 3 arrays (10 elements each)	8,546 ops/sec [8,523..8,565] → 8,723 ops/sec [8,601..8,967]	🟢 +2.1%	10,138 ops/sec [9,756..10,692] → 12,285 ops/sec [11,762..15,093]	🟢 +21.2%
zip 2 arrays (20 + 20 elements)	5,724 ops/sec [5,581..5,810] → 6,097 ops/sec [5,343..6,943]	~ overlap (+6.5%)	6,903 ops/sec [6,544..7,840] → 7,558 ops/sec [7,387..7,872]	~ overlap (+9.5%)
zip 2 arrays (50 + 50 elements)	2,555 ops/sec [2,521..2,580] → 2,655 ops/sec [2,439..2,882]	~ overlap (+3.9%)	3,025 ops/sec [2,931..3,176] → 3,514 ops/sec [3,460..3,563]	🟢 +16.2%
zip shortest mode (20 + 10 elements)	9,639 ops/sec [9,062..12,227] → 8,962 ops/sec [8,788..9,391]	~ overlap (-7.0%)	11,211 ops/sec [10,674..12,098] → 13,232 ops/sec [12,702..13,495]	🟢 +18.0%
zip longest mode (10 + 20 elements)	5,513 ops/sec [5,424..5,833] → 5,444 ops/sec [5,328..5,498]	~ overlap (-1.3%)	6,286 ops/sec [6,193..7,208] → 7,442 ops/sec [7,336..7,760]	🟢 +18.4%
zip strict mode (20 + 20 elements)	5,461 ops/sec [5,436..5,595] → 5,347 ops/sec [5,227..5,840]	~ overlap (-2.1%)	6,422 ops/sec [6,339..6,593] → 7,664 ops/sec [7,571..7,775]	🟢 +19.4%
zip + map + toArray (20 + 20 elements)	1,876 ops/sec [1,797..2,156] → 1,798 ops/sec [1,729..2,152]	~ overlap (-4.2%)	2,078 ops/sec [2,053..2,199] → 2,447 ops/sec [2,223..2,499]	🟢 +17.7%
zip + filter + toArray (20 + 20 elements)	2,053 ops/sec [1,963..2,814] → 1,928 ops/sec [1,904..1,935]	🔴 -6.1%	2,261 ops/sec [2,243..2,273] → 2,698 ops/sec [2,599..2,735]	🟢 +19.3%
zip Sets (15 + 15 elements)	7,986 ops/sec [7,829..8,467] → 7,893 ops/sec [7,712..7,957]	~ overlap (-1.2%)	8,856 ops/sec [8,587..8,968] → 10,442 ops/sec [10,167..11,039]	🟢 +17.9%
zipKeyed 2 keys (10 elements each)	9,335 ops/sec [9,157..9,713] → 9,274 ops/sec [9,207..9,346]	~ overlap (-0.6%)	11,281 ops/sec [11,060..11,533] → 12,413 ops/sec [11,629..13,868]	🟢 +10.0%
zipKeyed 3 keys (20 elements each)	4,761 ops/sec [4,638..4,953] → 4,693 ops/sec [4,580..5,287]	~ overlap (-1.4%)	5,555 ops/sec [5,490..5,581] → 6,326 ops/sec [6,207..6,515]	🟢 +13.9%
zipKeyed longest mode (10 + 20 elements)	5,296 ops/sec [5,258..5,968] → 5,070 ops/sec [4,924..5,325]	~ overlap (-4.3%)	6,383 ops/sec [5,933..6,393] → 7,234 ops/sec [6,908..8,517]	🟢 +13.3%
zipKeyed strict mode (20 + 20 elements)	5,162 ops/sec [5,103..5,284] → 5,071 ops/sec [4,679..5,180]	~ overlap (-1.8%)	6,699 ops/sec [5,927..6,968] → 7,024 ops/sec [6,118..7,422]	~ overlap (+4.9%)
zipKeyed + filter + map (20 elements)	1,763 ops/sec [1,657..1,800] → 1,692 ops/sec [1,681..1,720]	~ overlap (-4.0%)	2,273 ops/sec [2,184..2,634] → 2,494 ops/sec [2,451..2,710]	~ overlap (+9.7%)
array.values().map().filter().toArray()	721 ops/sec [690..858] → 689 ops/sec [670..740]	~ overlap (-4.5%)	847 ops/sec [816..861] → 938 ops/sec [921..965]	🟢 +10.8%
array.values().take(5).toArray()	11,593 ops/sec [11,268..11,775] → 11,550 ops/sec [11,304..14,897]	~ overlap (-0.4%)	13,797 ops/sec [13,626..13,887] → 15,693 ops/sec [15,346..16,445]	🟢 +13.7%
array.values().drop(45).toArray()	2,456 ops/sec [2,426..2,953] → 2,360 ops/sec [2,318..2,699]	~ overlap (-3.9%)	2,724 ops/sec [2,693..3,481] → 3,326 ops/sec [3,118..3,694]	~ overlap (+22.1%)
map.entries() chained helpers	1,020 ops/sec [984..1,039] → 927 ops/sec [919..936]	🔴 -9.1%	1,076 ops/sec [1,060..1,097] → 1,291 ops/sec [1,238..1,313]	🟢 +19.9%
set.values() chained helpers	1,723 ops/sec [1,682..1,753] → 1,697 ops/sec [1,676..1,882]	~ overlap (-1.5%)	2,111 ops/sec [2,006..2,293] → 2,523 ops/sec [2,499..2,578]	🟢 +19.5%
string iterator map + toArray	1,701 ops/sec [1,440..1,744] → 1,723 ops/sec [1,603..1,850]	~ overlap (+1.3%)	2,044 ops/sec [1,958..2,094] → 2,388 ops/sec [2,295..2,432]	🟢 +16.8%

json.js — Interp: 🟢 1, 🔴 2, 20 unch. · avg +1.3% · Bytecode: 🔴 4, 19 unch. · avg -1.8%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple object	36,940 ops/sec [36,863..36,952] → 34,265 ops/sec [33,693..34,585]	🔴 -7.2%	47,840 ops/sec [47,262..51,332] → 50,021 ops/sec [49,130..51,783]	~ overlap (+4.6%)
parse nested object	23,193 ops/sec [22,987..26,481] → 21,818 ops/sec [21,624..22,164]	🔴 -5.9%	30,287 ops/sec [28,518..31,604] → 29,495 ops/sec [27,971..29,815]	~ overlap (-2.6%)
parse array of objects	14,209 ops/sec [13,868..14,904] → 13,899 ops/sec [13,840..17,664]	~ overlap (-2.2%)	18,497 ops/sec [18,246..18,689] → 17,011 ops/sec [16,907..18,218]	🔴 -8.0%
parse large flat object	14,370 ops/sec [14,011..14,527] → 14,908 ops/sec [14,391..14,990]	~ overlap (+3.7%)	19,973 ops/sec [19,336..21,929] → 19,065 ops/sec [17,514..20,364]	~ overlap (-4.5%)
parse mixed types	12,605 ops/sec [12,014..13,127] → 15,197 ops/sec [14,544..15,690]	🟢 +20.6%	16,634 ops/sec [16,079..21,490] → 16,288 ops/sec [15,862..16,914]	~ overlap (-2.1%)
stringify simple object	46,115 ops/sec [45,899..46,584] → 46,157 ops/sec [44,390..47,575]	~ overlap (+0.1%)	58,483 ops/sec [56,730..59,282] → 59,886 ops/sec [58,340..61,432]	~ overlap (+2.4%)
stringify nested object	27,975 ops/sec [26,582..29,503] → 27,717 ops/sec [26,873..31,064]	~ overlap (-0.9%)	32,620 ops/sec [31,522..34,463] → 31,632 ops/sec [30,321..32,309]	~ overlap (-3.0%)
stringify array of objects	12,048 ops/sec [11,435..12,949] → 12,512 ops/sec [11,636..14,447]	~ overlap (+3.9%)	15,708 ops/sec [14,850..17,127] → 15,784 ops/sec [15,209..17,578]	~ overlap (+0.5%)
stringify mixed types	23,216 ops/sec [22,575..24,871] → 23,411 ops/sec [23,282..23,801]	~ overlap (+0.8%)	27,274 ops/sec [25,662..32,546] → 28,365 ops/sec [27,733..30,011]	~ overlap (+4.0%)
reviver doubles numbers	7,898 ops/sec [7,681..9,307] → 8,010 ops/sec [7,800..8,954]	~ overlap (+1.4%)	12,953 ops/sec [12,440..13,633] → 13,708 ops/sec [13,417..15,311]	~ overlap (+5.8%)
reviver filters properties	7,862 ops/sec [7,773..7,903] → 7,665 ops/sec [7,596..7,786]	~ overlap (-2.5%)	11,978 ops/sec [11,638..12,385] → 12,263 ops/sec [11,792..12,364]	~ overlap (+2.4%)
reviver on nested object	8,986 ops/sec [8,765..9,125] → 9,609 ops/sec [8,985..10,280]	~ overlap (+6.9%)	13,984 ops/sec [13,450..14,156] → 14,089 ops/sec [13,062..14,403]	~ overlap (+0.7%)
reviver on array	4,910 ops/sec [4,803..4,980] → 4,928 ops/sec [4,821..4,968]	~ overlap (+0.4%)	8,676 ops/sec [8,370..10,086] → 8,421 ops/sec [7,811..9,269]	~ overlap (-2.9%)
replacer function doubles numbers	10,239 ops/sec [10,063..11,031] → 9,989 ops/sec [9,701..10,291]	~ overlap (-2.4%)	17,595 ops/sec [16,984..17,808] → 17,379 ops/sec [15,701..18,845]	~ overlap (-1.2%)
replacer function excludes properties	13,347 ops/sec [12,978..15,448] → 13,612 ops/sec [13,064..15,011]	~ overlap (+2.0%)	22,298 ops/sec [21,712..25,315] → 20,960 ops/sec [20,593..21,482]	🔴 -6.0%
array replacer (allowlist)	35,838 ops/sec [34,387..43,938] → 35,983 ops/sec [35,556..37,087]	~ overlap (+0.4%)	46,941 ops/sec [45,683..48,139] → 42,856 ops/sec [41,306..44,687]	🔴 -8.7%
stringify with 2-space indent	27,797 ops/sec [26,767..30,001] → 27,276 ops/sec [24,907..29,357]	~ overlap (-1.9%)	34,641 ops/sec [33,078..35,763] → 32,804 ops/sec [32,276..33,352]	~ overlap (-5.3%)
stringify with tab indent	27,253 ops/sec [26,760..28,590] → 27,504 ops/sec [26,808..28,497]	~ overlap (+0.9%)	32,977 ops/sec [31,652..34,879] → 32,895 ops/sec [31,925..37,072]	~ overlap (-0.3%)
stringify deeply nested object with 2-space indent	3,997 ops/sec [3,924..4,364] → 4,156 ops/sec [3,910..4,856]	~ overlap (+4.0%)	5,403 ops/sec [5,314..5,472] → 4,995 ops/sec [4,891..5,152]	🔴 -7.5%
stringify deeply nested array with 2-space indent	5,971 ops/sec [5,778..6,381] → 6,077 ops/sec [5,756..6,183]	~ overlap (+1.8%)	7,772 ops/sec [7,507..7,951] → 7,469 ops/sec [7,196..7,712]	~ overlap (-3.9%)
stringify very deeply nested object with 2-space indent	713 ops/sec [685..823] → 772 ops/sec [714..818]	~ overlap (+8.3%)	835 ops/sec [783..891] → 816 ops/sec [808..837]	~ overlap (-2.4%)
parse then stringify	12,678 ops/sec [11,983..15,730] → 12,679 ops/sec [12,210..13,160]	~ overlap (+0.0%)	17,521 ops/sec [17,393..17,966] → 16,932 ops/sec [16,613..17,431]	~ overlap (-3.4%)
stringify then parse	7,886 ops/sec [7,432..8,759] → 7,794 ops/sec [7,735..9,581]	~ overlap (-1.2%)	10,108 ops/sec [9,035..10,558] → 10,105 ops/sec [9,848..10,247]	~ overlap (-0.0%)

jsx.jsx — Interp: 🟢 7, 14 unch. · avg +5.2% · Bytecode: 🟢 5, 16 unch. · avg +6.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple element	67,285 ops/sec [65,457..69,732] → 68,499 ops/sec [68,097..70,584]	~ overlap (+1.8%)	108,004 ops/sec [102,572..122,941] → 113,688 ops/sec [107,039..117,622]	~ overlap (+5.3%)
self-closing element	67,526 ops/sec [67,252..68,150] → 71,722 ops/sec [70,622..71,835]	🟢 +6.2%	114,389 ops/sec [112,666..115,623] → 115,001 ops/sec [111,428..117,262]	~ overlap (+0.5%)
element with string attribute	57,696 ops/sec [57,083..58,879] → 61,680 ops/sec [60,653..68,695]	🟢 +6.9%	85,842 ops/sec [83,861..89,914] → 93,421 ops/sec [90,340..95,387]	🟢 +8.8%
element with multiple attributes	50,582 ops/sec [49,635..51,130] → 52,703 ops/sec [52,557..53,670]	🟢 +4.2%	62,603 ops/sec [59,778..63,500] → 66,306 ops/sec [62,418..67,833]	~ overlap (+5.9%)
element with expression attribute	50,409 ops/sec [50,034..50,938] → 51,813 ops/sec [51,050..59,756]	🟢 +2.8%	84,465 ops/sec [83,920..84,823] → 95,683 ops/sec [89,436..98,261]	🟢 +13.3%
text child	67,973 ops/sec [67,044..68,772] → 69,450 ops/sec [68,359..70,426]	~ overlap (+2.2%)	120,586 ops/sec [106,766..123,772] → 120,243 ops/sec [118,033..129,914]	~ overlap (-0.3%)
expression child	60,743 ops/sec [59,796..61,390] → 63,311 ops/sec [61,205..66,925]	~ overlap (+4.2%)	109,856 ops/sec [103,755..157,111] → 117,090 ops/sec [108,022..140,488]	~ overlap (+6.6%)
mixed text and expression	56,605 ops/sec [56,341..56,996] → 61,386 ops/sec [58,119..67,923]	🟢 +8.4%	94,279 ops/sec [90,345..97,010] → 102,679 ops/sec [94,881..106,770]	~ overlap (+8.9%)
nested elements (3 levels)	27,291 ops/sec [27,043..27,316] → 28,209 ops/sec [28,020..28,365]	🟢 +3.4%	42,764 ops/sec [41,289..44,221] → 45,642 ops/sec [44,564..46,667]	🟢 +6.7%
sibling children	21,396 ops/sec [20,669..25,278] → 22,763 ops/sec [21,022..23,554]	~ overlap (+6.4%)	31,298 ops/sec [30,172..32,667] → 32,526 ops/sec [29,605..37,693]	~ overlap (+3.9%)
component element	50,801 ops/sec [48,275..54,967] → 50,724 ops/sec [47,699..58,173]	~ overlap (-0.2%)	85,440 ops/sec [81,410..91,261] → 87,297 ops/sec [84,066..91,266]	~ overlap (+2.2%)
component with children	30,801 ops/sec [29,617..31,552] → 35,588 ops/sec [31,420..40,940]	~ overlap (+15.5%)	50,938 ops/sec [49,924..53,996] → 54,872 ops/sec [52,929..55,195]	~ overlap (+7.7%)
dotted component	41,683 ops/sec [40,085..43,553] → 43,935 ops/sec [41,289..50,501]	~ overlap (+5.4%)	68,806 ops/sec [63,811..73,499] → 66,841 ops/sec [65,295..68,451]	~ overlap (-2.9%)
empty fragment	69,589 ops/sec [68,045..74,541] → 71,447 ops/sec [70,575..77,805]	~ overlap (+2.7%)	120,449 ops/sec [117,034..125,434] → 127,012 ops/sec [124,266..132,646]	~ overlap (+5.4%)
fragment with children	21,379 ops/sec [21,073..21,453] → 22,831 ops/sec [21,284..26,524]	~ overlap (+6.8%)	33,436 ops/sec [32,177..35,162] → 35,504 ops/sec [34,220..40,350]	~ overlap (+6.2%)
spread attributes	32,202 ops/sec [31,047..36,594] → 37,976 ops/sec [31,512..40,272]	~ overlap (+17.9%)	44,833 ops/sec [44,478..46,584] → 49,498 ops/sec [48,461..49,958]	🟢 +10.4%
spread with overrides	28,245 ops/sec [27,407..28,656] → 29,358 ops/sec [28,562..29,725]	~ overlap (+3.9%)	37,785 ops/sec [37,427..39,071] → 41,077 ops/sec [38,975..42,434]	~ overlap (+8.7%)
shorthand props	48,113 ops/sec [46,564..54,613] → 50,162 ops/sec [48,354..60,102]	~ overlap (+4.3%)	72,445 ops/sec [67,885..75,125] → 79,839 ops/sec [77,089..80,659]	🟢 +10.2%
nav bar structure	10,267 ops/sec [10,067..10,886] → 10,462 ops/sec [10,303..11,515]	~ overlap (+1.9%)	15,299 ops/sec [14,336..16,626] → 16,152 ops/sec [15,588..17,271]	~ overlap (+5.6%)
card component tree	11,625 ops/sec [11,537..11,640] → 12,121 ops/sec [11,796..12,715]	🟢 +4.3%	16,252 ops/sec [15,864..19,529] → 17,826 ops/sec [17,018..18,593]	~ overlap (+9.7%)
10 list items via Array.from	4,971 ops/sec [4,616..5,619] → 5,012 ops/sec [4,907..5,379]	~ overlap (+0.8%)	6,310 ops/sec [5,958..7,145] → 6,479 ops/sec [6,312..6,945]	~ overlap (+2.7%)

modules.js — Interp: 🔴 2, 7 unch. · avg -3.0% · Bytecode: 9 unch. · avg +5.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
call imported function	107,908 ops/sec [106,657..109,173] → 104,377 ops/sec [101,367..106,140]	🔴 -3.3%	51,882 ops/sec [50,039..54,817] → 55,884 ops/sec [53,428..83,982]	~ overlap (+7.7%)
call two imported functions	60,513 ops/sec [57,668..62,979] → 57,668 ops/sec [57,500..57,810]	~ overlap (-4.7%)	26,642 ops/sec [25,263..29,968] → 27,959 ops/sec [27,310..30,528]	~ overlap (+4.9%)
read imported constant	266,012 ops/sec [257,450..275,568] → 267,025 ops/sec [256,739..283,667]	~ overlap (+0.4%)	53,885 ops/sec [53,440..58,098] → 63,054 ops/sec [55,700..66,289]	~ overlap (+17.0%)
read imported string	266,277 ops/sec [255,204..270,481] → 272,843 ops/sec [266,785..296,900]	~ overlap (+2.5%)	58,110 ops/sec [54,301..62,604] → 56,127 ops/sec [55,797..60,396]	~ overlap (-3.4%)
read JSON string property	280,151 ops/sec [259,583..300,270] → 260,054 ops/sec [254,727..260,671]	~ overlap (-7.2%)	53,347 ops/sec [52,125..55,699] → 57,627 ops/sec [54,121..58,874]	~ overlap (+8.0%)
read JSON number property	278,886 ops/sec [263,832..312,669] → 260,895 ops/sec [252,783..262,730]	🔴 -6.5%	55,070 ops/sec [54,539..60,018] → 55,799 ops/sec [53,791..60,894]	~ overlap (+1.3%)
read JSON boolean property	274,879 ops/sec [262,147..278,504] → 266,191 ops/sec [261,340..294,605]	~ overlap (-3.2%)	55,230 ops/sec [52,517..56,772] → 57,070 ops/sec [55,587..61,642]	~ overlap (+3.3%)
read JSON array property	283,914 ops/sec [259,051..320,059] → 267,477 ops/sec [255,019..276,684]	~ overlap (-5.8%)	55,221 ops/sec [54,727..56,442] → 56,806 ops/sec [54,123..66,633]	~ overlap (+2.9%)
read multiple JSON properties	134,463 ops/sec [133,612..135,245] → 135,023 ops/sec [129,903..143,307]	~ overlap (+0.4%)	19,578 ops/sec [18,502..19,867] → 21,790 ops/sec [19,596..25,374]	~ overlap (+11.3%)

numbers.js — Interp: 12 unch. · avg -1.0% · Bytecode: 🟢 2, 10 unch. · avg +6.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
integer arithmetic	64,975 ops/sec [61,787..68,221] → 62,853 ops/sec [62,287..63,927]	~ overlap (-3.3%)	517,943 ops/sec [503,216..704,084] → 600,013 ops/sec [584,216..609,734]	~ overlap (+15.8%)
floating point arithmetic	78,997 ops/sec [74,105..80,840] → 73,779 ops/sec [72,244..77,531]	~ overlap (-6.6%)	442,756 ops/sec [434,732..494,646] → 522,074 ops/sec [480,476..586,924]	~ overlap (+17.9%)
number coercion	15,746 ops/sec [15,432..16,055] → 15,809 ops/sec [15,604..18,269]	~ overlap (+0.4%)	24,520 ops/sec [22,629..27,525] → 26,070 ops/sec [23,041..27,505]	~ overlap (+6.3%)
toFixed	26,801 ops/sec [25,912..32,194] → 27,463 ops/sec [27,411..27,624]	~ overlap (+2.5%)	43,981 ops/sec [41,163..51,713] → 44,528 ops/sec [41,027..50,466]	~ overlap (+1.2%)
toString	42,131 ops/sec [40,069..43,028] → 41,713 ops/sec [39,578..42,580]	~ overlap (-1.0%)	79,970 ops/sec [76,726..83,282] → 81,643 ops/sec [75,499..86,057]	~ overlap (+2.1%)
toString non-integer (shortest round-trip)	8,771 ops/sec [8,688..9,700] → 8,906 ops/sec [8,615..9,364]	~ overlap (+1.5%)	20,452 ops/sec [19,796..21,396] → 21,854 ops/sec [21,469..23,906]	🟢 +6.9%
valueOf	60,987 ops/sec [54,912..61,017] → 56,154 ops/sec [54,550..56,632]	~ overlap (-7.9%)	107,528 ops/sec [102,150..110,424] → 110,487 ops/sec [105,340..113,087]	~ overlap (+2.8%)
toPrecision	25,325 ops/sec [24,941..28,186] → 26,404 ops/sec [24,835..26,548]	~ overlap (+4.3%)	38,079 ops/sec [36,125..40,486] → 39,832 ops/sec [38,577..42,520]	~ overlap (+4.6%)
Number.isNaN	56,405 ops/sec [55,853..57,015] → 55,785 ops/sec [55,432..59,350]	~ overlap (-1.1%)	109,099 ops/sec [104,157..118,591] → 113,707 ops/sec [112,210..124,837]	~ overlap (+4.2%)
Number.isFinite	54,902 ops/sec [54,596..57,101] → 54,976 ops/sec [53,189..86,715]	~ overlap (+0.1%)	104,904 ops/sec [96,103..132,898] → 110,499 ops/sec [108,808..110,780]	~ overlap (+5.3%)
Number.isInteger	57,905 ops/sec [57,824..58,125] → 58,513 ops/sec [56,315..59,019]	~ overlap (+1.0%)	104,936 ops/sec [99,199..112,841] → 112,069 ops/sec [108,437..114,180]	~ overlap (+6.8%)
Number.parseInt and parseFloat	21,506 ops/sec [20,990..26,645] → 21,157 ops/sec [18,436..23,257]	~ overlap (-1.6%)	28,687 ops/sec [27,456..29,776] → 31,334 ops/sec [30,656..34,446]	🟢 +9.2%

objects.js — Interp: 7 unch. · avg +0.9% · Bytecode: 7 unch. · avg -2.3%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
create simple object	131,694 ops/sec [128,156..160,951] → 133,902 ops/sec [130,948..136,454]	~ overlap (+1.7%)	152,783 ops/sec [144,534..160,091] → 150,457 ops/sec [144,409..152,830]	~ overlap (-1.5%)
create nested object	74,896 ops/sec [72,065..77,131] → 76,485 ops/sec [73,436..81,594]	~ overlap (+2.1%)	74,865 ops/sec [70,239..84,163] → 70,865 ops/sec [69,028..71,976]	~ overlap (-5.3%)
create 50 objects via Array.from	2,670 ops/sec [2,620..4,158] → 2,592 ops/sec [2,572..3,060]	~ overlap (-2.9%)	2,680 ops/sec [2,574..3,371] → 2,563 ops/sec [2,504..2,608]	~ overlap (-4.3%)
property read	98,285 ops/sec [95,850..128,918] → 100,708 ops/sec [100,180..101,430]	~ overlap (+2.5%)	444,303 ops/sec [422,833..508,069] → 430,899 ops/sec [421,609..447,792]	~ overlap (-3.0%)
Object.keys	62,100 ops/sec [61,485..63,729] → 64,631 ops/sec [61,821..76,268]	~ overlap (+4.1%)	91,646 ops/sec [86,350..92,862] → 94,994 ops/sec [90,098..104,747]	~ overlap (+3.7%)
Object.entries	34,051 ops/sec [33,456..39,088] → 34,718 ops/sec [32,693..38,056]	~ overlap (+2.0%)	46,907 ops/sec [45,216..47,825] → 44,534 ops/sec [42,844..61,400]	~ overlap (-5.1%)
spread operator	43,430 ops/sec [41,110..46,797] → 42,089 ops/sec [41,066..43,056]	~ overlap (-3.1%)	56,659 ops/sec [55,510..59,497] → 56,487 ops/sec [54,405..65,036]	~ overlap (-0.3%)

promises.js — Interp: 🟢 1, 🔴 1, 10 unch. · avg +2.9% · Bytecode: 🟢 3, 9 unch. · avg +5.3%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Promise.resolve(value)	59,633 ops/sec [58,851..63,590] → 62,227 ops/sec [61,726..62,632]	~ overlap (+4.4%)	85,700 ops/sec [81,975..87,888] → 85,811 ops/sec [83,357..87,774]	~ overlap (+0.1%)
new Promise(resolve => resolve(value))	43,165 ops/sec [42,909..43,540] → 47,218 ops/sec [42,315..56,517]	~ overlap (+9.4%)	65,488 ops/sec [60,766..73,647] → 66,391 ops/sec [63,664..77,009]	~ overlap (+1.4%)
Promise.reject(reason)	60,806 ops/sec [59,167..66,007] → 63,771 ops/sec [60,173..76,890]	~ overlap (+4.9%)	85,266 ops/sec [80,349..87,696] → 93,519 ops/sec [86,176..107,068]	~ overlap (+9.7%)
resolve + then (1 handler)	20,048 ops/sec [19,986..23,276] → 20,634 ops/sec [20,398..20,824]	~ overlap (+2.9%)	28,237 ops/sec [26,400..32,532] → 30,364 ops/sec [29,682..32,778]	~ overlap (+7.5%)
resolve + then chain (3 deep)	8,571 ops/sec [8,506..9,126] → 8,795 ops/sec [8,604..9,437]	~ overlap (+2.6%)	11,682 ops/sec [11,519..11,852] → 12,711 ops/sec [12,476..12,824]	🟢 +8.8%
resolve + then chain (10 deep)	2,867 ops/sec [2,780..3,016] → 3,009 ops/sec [2,885..3,704]	~ overlap (+4.9%)	4,007 ops/sec [3,845..4,148] → 4,154 ops/sec [4,105..4,224]	~ overlap (+3.7%)
reject + catch + then	12,506 ops/sec [12,411..12,601] → 12,202 ops/sec [11,903..12,293]	🔴 -2.4%	16,105 ops/sec [15,931..16,583] → 16,404 ops/sec [14,827..16,885]	~ overlap (+1.9%)
resolve + finally + then	5,779 ops/sec [5,703..5,821] → 5,719 ops/sec [5,653..6,178]	~ overlap (-1.0%)	7,589 ops/sec [7,563..7,662] → 8,570 ops/sec [8,013..8,955]	🟢 +12.9%
Promise.all (5 resolved)	3,867 ops/sec [3,711..3,876] → 3,912 ops/sec [3,778..4,160]	~ overlap (+1.2%)	5,205 ops/sec [5,010..5,480] → 5,555 ops/sec [5,436..5,634]	~ overlap (+6.7%)
Promise.race (5 resolved)	4,397 ops/sec [4,315..4,421] → 4,580 ops/sec [4,428..5,852]	🟢 +4.2%	5,877 ops/sec [5,457..5,951] → 6,251 ops/sec [6,008..6,419]	🟢 +6.4%
Promise.allSettled (5 mixed)	3,349 ops/sec [3,120..3,526] → 3,409 ops/sec [3,304..3,650]	~ overlap (+1.8%)	4,503 ops/sec [4,187..5,243] → 4,502 ops/sec [4,375..4,632]	~ overlap (-0.0%)
Promise.any (5 mixed)	3,991 ops/sec [3,840..4,045] → 4,071 ops/sec [3,881..4,247]	~ overlap (+2.0%)	5,187 ops/sec [5,133..5,622] → 5,437 ops/sec [5,008..5,781]	~ overlap (+4.8%)

property-access.js — Interp: 🔴 1, 4 unch. · avg +0.2% · Bytecode: 🟢 2, 3 unch. · avg +6.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
class instance fields across 1000 instances	112 ops/sec [106..116] → 112 ops/sec [108..115]	~ overlap (+0.3%)	1,157 ops/sec [1,121..1,207] → 1,199 ops/sec [1,179..1,239]	~ overlap (+3.7%)
object literal fields across 1000 literals	114 ops/sec [112..140] → 113 ops/sec [107..115]	~ overlap (-0.3%)	1,217 ops/sec [1,159..1,253] → 1,214 ops/sec [1,195..1,423]	~ overlap (-0.2%)
mixed-shape literals across 1000 literals	113 ops/sec [113..114] → 113 ops/sec [110..116]	~ overlap (-0.5%)	752 ops/sec [749..763] → 825 ops/sec [785..927]	🟢 +9.7%
own-class method across 1000 instances	75 ops/sec [75..77] → 73 ops/sec [72..74]	🔴 -2.1%	501 ops/sec [474..527] → 572 ops/sec [542..576]	🟢 +14.3%
inherited method across 1000 instances	79 ops/sec [79..81] → 82 ops/sec [70..95]	~ overlap (+3.5%)	604 ops/sec [564..824] → 623 ops/sec [556..675]	~ overlap (+3.1%)

regexp.js — Interp: 13 unch. · avg +0.7% · Bytecode: 🟢 4, 9 unch. · avg +4.8%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
regex literal creation	7,877 ops/sec [7,634..8,197] → 8,014 ops/sec [7,108..8,702]	~ overlap (+1.7%)	248,866 ops/sec [244,951..265,595] → 259,742 ops/sec [250,109..261,975]	~ overlap (+4.4%)
new RegExp(pattern, flags)	7,617 ops/sec [7,399..8,167] → 7,937 ops/sec [7,467..8,536]	~ overlap (+4.2%)	9,549 ops/sec [9,297..9,628] → 10,278 ops/sec [9,911..10,906]	🟢 +7.6%
RegExp(existingRegex) returns the same regex	136,781 ops/sec [136,235..137,273] → 140,233 ops/sec [136,397..161,244]	~ overlap (+2.5%)	262,624 ops/sec [252,156..280,027] → 298,542 ops/sec [291,697..302,248]	🟢 +13.7%
test() on a global regex	62,735 ops/sec [61,802..73,785] → 62,304 ops/sec [59,733..77,982]	~ overlap (-0.7%)	108,312 ops/sec [99,972..126,034] → 102,903 ops/sec [101,639..105,611]	~ overlap (-5.0%)
exec() with capture groups	35,389 ops/sec [34,647..46,304] → 34,835 ops/sec [34,245..35,815]	~ overlap (-1.6%)	52,032 ops/sec [51,019..53,709] → 52,586 ops/sec [48,442..53,080]	~ overlap (+1.1%)
toString()	48,739 ops/sec [48,523..50,715] → 50,132 ops/sec [49,787..64,054]	~ overlap (+2.9%)	77,033 ops/sec [73,993..79,222] → 77,329 ops/sec [75,291..77,940]	~ overlap (+0.4%)
match() with global regex	22,719 ops/sec [21,929..23,585] → 22,342 ops/sec [21,906..23,891]	~ overlap (-1.7%)	35,002 ops/sec [31,801..40,797] → 34,747 ops/sec [33,959..36,369]	~ overlap (-0.7%)
match() with many global results	1,135 ops/sec [1,102..1,154] → 1,166 ops/sec [1,103..1,218]	~ overlap (+2.7%)	1,430 ops/sec [1,352..1,679] → 1,463 ops/sec [1,451..1,511]	~ overlap (+2.4%)
matchAll() with capture groups	7,662 ops/sec [7,432..8,837] → 7,797 ops/sec [7,477..8,095]	~ overlap (+1.8%)	13,915 ops/sec [13,211..19,667] → 14,960 ops/sec [14,582..15,590]	~ overlap (+7.5%)
replace() with global regex	20,861 ops/sec [19,409..21,246] → 20,758 ops/sec [20,702..20,908]	~ overlap (-0.5%)	30,862 ops/sec [30,044..32,164] → 33,044 ops/sec [32,801..33,693]	🟢 +7.1%
replace() with many global results	856 ops/sec [826..907] → 848 ops/sec [824..859]	~ overlap (-0.9%)	1,035 ops/sec [925..1,071] → 1,151 ops/sec [1,100..1,196]	🟢 +11.2%
search() with regex	40,280 ops/sec [39,535..40,778] → 39,733 ops/sec [39,487..40,553]	~ overlap (-1.4%)	69,868 ops/sec [66,015..74,565] → 73,160 ops/sec [66,258..74,076]	~ overlap (+4.7%)
split() with regex separator	9,897 ops/sec [9,643..10,805] → 9,884 ops/sec [9,683..11,050]	~ overlap (-0.1%)	13,062 ops/sec [12,785..13,378] → 14,061 ops/sec [13,221..15,129]	~ overlap (+7.6%)

strings.js — Interp: 🔴 1, 18 unch. · avg -0.2% · Bytecode: 🟢 6, 13 unch. · avg +7.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
string concatenation	86,986 ops/sec [86,385..91,023] → 85,483 ops/sec [84,894..86,244]	🔴 -1.7%	574,910 ops/sec [545,563..657,770] → 595,002 ops/sec [563,744..667,990]	~ overlap (+3.5%)
template literal	149,989 ops/sec [148,793..153,311] → 147,093 ops/sec [142,875..152,889]	~ overlap (-1.9%)	466,392 ops/sec [448,386..544,521] → 476,494 ops/sec [453,039..528,969]	~ overlap (+2.2%)
string repeat	96,467 ops/sec [95,768..98,460] → 94,065 ops/sec [92,762..107,395]	~ overlap (-2.5%)	163,810 ops/sec [156,222..177,091] → 173,080 ops/sec [161,082..190,729]	~ overlap (+5.7%)
split and join	44,580 ops/sec [41,602..57,013] → 44,844 ops/sec [42,359..55,562]	~ overlap (+0.6%)	70,066 ops/sec [69,025..70,549] → 75,116 ops/sec [67,323..81,257]	~ overlap (+7.2%)
indexOf and includes	39,508 ops/sec [38,999..39,827] → 40,159 ops/sec [39,326..44,977]	~ overlap (+1.6%)	64,047 ops/sec [59,599..66,318] → 72,354 ops/sec [66,686..77,735]	🟢 +13.0%
toUpperCase and toLowerCase	36,641 ops/sec [36,076..36,735] → 37,316 ops/sec [36,590..38,881]	~ overlap (+1.8%)	56,690 ops/sec [55,576..59,553] → 61,057 ops/sec [59,216..62,146]	~ overlap (+7.7%)
slice and substring	36,864 ops/sec [35,985..38,217] → 37,655 ops/sec [35,814..43,266]	~ overlap (+2.1%)	64,334 ops/sec [61,966..66,580] → 71,368 ops/sec [68,409..75,811]	🟢 +10.9%
trim operations	41,404 ops/sec [40,948..45,019] → 40,865 ops/sec [39,701..43,894]	~ overlap (-1.3%)	74,539 ops/sec [69,718..79,844] → 76,700 ops/sec [76,268..80,656]	~ overlap (+2.9%)
replace and replaceAll	47,671 ops/sec [46,873..48,024] → 47,028 ops/sec [44,719..47,569]	~ overlap (-1.3%)	71,662 ops/sec [71,018..74,591] → 79,383 ops/sec [77,195..82,147]	🟢 +10.8%
startsWith and endsWith	32,189 ops/sec [31,668..39,417] → 31,013 ops/sec [30,566..33,787]	~ overlap (-3.7%)	52,867 ops/sec [50,650..55,655] → 56,678 ops/sec [53,038..73,163]	~ overlap (+7.2%)
padStart and padEnd	50,323 ops/sec [49,760..52,413] → 49,935 ops/sec [49,309..51,081]	~ overlap (-0.8%)	86,808 ops/sec [82,612..91,001] → 95,910 ops/sec [93,594..104,993]	🟢 +10.5%
identity tag, no substitutions	103,465 ops/sec [100,970..135,222] → 104,903 ops/sec [102,241..109,952]	~ overlap (+1.4%)	193,912 ops/sec [185,549..252,231] → 219,741 ops/sec [200,660..232,929]	~ overlap (+13.3%)
tag with 1 substitution	22,833 ops/sec [22,204..23,522] → 22,945 ops/sec [22,446..27,680]	~ overlap (+0.5%)	39,252 ops/sec [37,349..42,826] → 42,078 ops/sec [41,709..43,342]	~ overlap (+7.2%)
tag with 3 substitutions	13,016 ops/sec [12,684..13,086] → 12,945 ops/sec [12,354..13,084]	~ overlap (-0.5%)	25,714 ops/sec [23,636..27,699] → 24,255 ops/sec [22,613..25,428]	~ overlap (-5.7%)
tag with 6 substitutions	7,733 ops/sec [7,721..7,753] → 7,610 ops/sec [7,364..8,925]	~ overlap (-1.6%)	13,959 ops/sec [12,579..14,010] → 15,870 ops/sec [15,722..16,055]	🟢 +13.7%
String.raw, no substitutions	90,688 ops/sec [89,640..95,727] → 91,567 ops/sec [87,884..123,962]	~ overlap (+1.0%)	117,454 ops/sec [114,684..119,252] → 129,085 ops/sec [121,656..136,177]	🟢 +9.9%
String.raw, 2 substitutions	62,807 ops/sec [62,513..62,960] → 63,195 ops/sec [58,654..66,376]	~ overlap (+0.6%)	88,906 ops/sec [86,510..100,303] → 95,953 ops/sec [94,203..98,393]	~ overlap (+7.9%)
tag accessing .raw array	37,906 ops/sec [37,201..38,001] → 38,439 ops/sec [37,913..38,621]	~ overlap (+1.4%)	58,592 ops/sec [54,968..60,195] → 64,549 ops/sec [58,287..66,733]	~ overlap (+10.2%)
method as tag (this binding)	15,758 ops/sec [15,654..15,856] → 15,718 ops/sec [15,626..15,820]	~ overlap (-0.3%)	28,724 ops/sec [28,260..28,856] → 29,268 ops/sec [28,598..30,169]	~ overlap (+1.9%)

temporal.js — Interp: 6 unch. · avg -0.1% · Bytecode: 🟢 3, 3 unch. · avg +8.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
PlainDate.add({ months: 1 })	38,254 ops/sec [37,423..38,544] → 37,449 ops/sec [36,092..44,271]	~ overlap (-2.1%)	52,592 ops/sec [48,186..54,559] → 57,141 ops/sec [56,764..62,775]	🟢 +8.6%
PlainDate.until(..., { largestUnit: 'months' })	44,934 ops/sec [44,717..45,170] → 46,774 ops/sec [43,840..51,097]	~ overlap (+4.1%)	62,116 ops/sec [61,227..74,962] → 66,692 ops/sec [64,017..69,765]	~ overlap (+7.4%)
Duration.total days relative to PlainDate	38,165 ops/sec [36,786..39,252] → 38,835 ops/sec [36,641..39,579]	~ overlap (+1.8%)	48,606 ops/sec [47,910..50,739] → 51,728 ops/sec [49,966..58,978]	~ overlap (+6.4%)
Duration.round to hours	31,414 ops/sec [30,816..33,410] → 30,020 ops/sec [29,372..31,119]	~ overlap (-4.4%)	39,562 ops/sec [39,191..40,414] → 44,997 ops/sec [44,726..45,367]	🟢 +13.7%
ZonedDateTime.from named time zone	8,672 ops/sec [8,479..9,372] → 8,478 ops/sec [8,132..9,151]	~ overlap (-2.2%)	10,919 ops/sec [10,661..11,227] → 11,945 ops/sec [11,330..14,600]	🟢 +9.4%
ZonedDateTime.since across DST	10,855 ops/sec [9,446..12,228] → 11,137 ops/sec [9,616..17,368]	~ overlap (+2.6%)	12,467 ops/sec [12,047..13,457] → 13,083 ops/sec [12,420..16,105]	~ overlap (+4.9%)

tsv.js — Interp: 🔴 1, 8 unch. · avg +0.1% · Bytecode: 🟢 1, 8 unch. · avg +7.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple 3-column TSV	38,846 ops/sec [37,564..39,520] → 40,060 ops/sec [37,812..44,825]	~ overlap (+3.1%)	43,232 ops/sec [42,540..48,516] → 49,448 ops/sec [47,637..50,871]	~ overlap (+14.4%)
parse 10-row TSV	11,338 ops/sec [11,262..11,481] → 11,458 ops/sec [11,286..12,325]	~ overlap (+1.1%)	13,264 ops/sec [12,734..17,461] → 14,677 ops/sec [13,819..15,106]	~ overlap (+10.7%)
parse 100-row TSV	1,806 ops/sec [1,797..1,826] → 1,763 ops/sec [1,743..1,789]	🔴 -2.4%	2,221 ops/sec [2,127..2,570] → 2,303 ops/sec [2,182..2,483]	~ overlap (+3.7%)
parse TSV with backslash-escaped fields	9,020 ops/sec [8,966..9,195] → 9,131 ops/sec [8,693..9,240]	~ overlap (+1.2%)	11,124 ops/sec [10,616..11,869] → 11,820 ops/sec [11,287..12,227]	~ overlap (+6.2%)
parse without headers (array of arrays)	5,615 ops/sec [5,365..5,986] → 5,584 ops/sec [5,373..5,709]	~ overlap (-0.5%)	6,674 ops/sec [6,385..7,148] → 6,958 ops/sec [6,815..7,131]	~ overlap (+4.3%)
stringify array of objects	11,881 ops/sec [11,528..11,979] → 11,958 ops/sec [11,765..12,456]	~ overlap (+0.6%)	14,469 ops/sec [14,344..15,148] → 16,173 ops/sec [14,721..18,264]	~ overlap (+11.8%)
stringify array of arrays	3,086 ops/sec [3,021..3,456] → 3,101 ops/sec [3,004..3,176]	~ overlap (+0.5%)	3,665 ops/sec [3,519..3,733] → 3,828 ops/sec [3,455..4,191]	~ overlap (+4.4%)
stringify with values needing escaping	9,963 ops/sec [9,667..10,980] → 9,719 ops/sec [9,547..10,878]	~ overlap (-2.4%)	11,741 ops/sec [11,607..11,806] → 12,597 ops/sec [12,433..12,806]	🟢 +7.3%
parse then stringify	3,831 ops/sec [3,798..3,891] → 3,820 ops/sec [3,779..3,856]	~ overlap (-0.3%)	4,455 ops/sec [4,296..4,764] → 4,807 ops/sec [4,586..5,074]	~ overlap (+7.9%)

typed-arrays.js — Interp: 🟢 5, 🔴 6, 11 unch. · avg -8.3% · Bytecode: 🟢 13, 9 unch. · avg +20.7%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
new Int32Array(0)	100,638 ops/sec [98,562..101,879] → 101,933 ops/sec [98,229..117,719]	~ overlap (+1.3%)	163,561 ops/sec [162,383..167,111] → 172,876 ops/sec [157,006..184,437]	~ overlap (+5.7%)
new Int32Array(100)	96,826 ops/sec [95,855..97,129] → 97,439 ops/sec [94,939..113,797]	~ overlap (+0.6%)	157,095 ops/sec [153,460..168,980] → 167,540 ops/sec [164,486..172,784]	~ overlap (+6.6%)
new Int32Array(1000)	73,785 ops/sec [72,467..74,439] → 76,749 ops/sec [74,757..87,270]	🟢 +4.0%	115,745 ops/sec [113,606..123,133] → 119,643 ops/sec [118,355..125,460]	~ overlap (+3.4%)
new Float64Array(100)	92,062 ops/sec [91,347..92,844] → 97,265 ops/sec [95,806..97,768]	🟢 +5.7%	146,402 ops/sec [144,227..149,591] → 151,981 ops/sec [144,898..164,672]	~ overlap (+3.8%)
Int32Array.from([...])	1,219 ops/sec [1,210..1,466] → 1,266 ops/sec [1,230..1,754]	~ overlap (+3.9%)	1,682 ops/sec [1,672..1,689] → 1,596 ops/sec [1,488..1,688]	~ overlap (-5.1%)
Int32Array.of(1, 2, 3, 4, 5)	64,537 ops/sec [64,102..64,646] → 63,674 ops/sec [62,357..65,551]	~ overlap (-1.3%)	91,750 ops/sec [90,890..93,946] → 101,961 ops/sec [101,623..103,494]	🟢 +11.1%
sequential write 100 elements	1,010 ops/sec [1,008..1,022] → 1,005 ops/sec [1,002..1,007]	🔴 -0.5%	8,528 ops/sec [8,387..8,784] → 9,165 ops/sec [8,904..9,641]	🟢 +7.5%
sequential read 100 elements	1,054 ops/sec [1,000..1,065] → 1,085 ops/sec [1,042..1,089]	~ overlap (+2.9%)	9,860 ops/sec [9,393..9,988] → 10,383 ops/sec [9,970..10,428]	~ overlap (+5.3%)
Float64Array write 100 elements	878 ops/sec [846..900] → 947 ops/sec [945..952]	🟢 +8.0%	7,078 ops/sec [6,950..7,326] → 7,968 ops/sec [7,831..8,614]	🟢 +12.6%
fill(42)	5,457 ops/sec [5,398..5,700] → 5,474 ops/sec [5,443..5,517]	~ overlap (+0.3%)	6,595 ops/sec [6,324..6,708] → 6,999 ops/sec [6,717..7,268]	🟢 +6.1%
slice()	50,266 ops/sec [49,905..51,079] → 52,093 ops/sec [51,372..52,403]	🟢 +3.6%	74,908 ops/sec [74,222..78,046] → 84,489 ops/sec [82,155..87,443]	🟢 +12.8%
map(x => x * 2)	3,123 ops/sec [1,901..3,133] → 1,935 ops/sec [1,900..1,940]	~ overlap (-38.0%)	2,543 ops/sec [2,477..2,570] → 4,226 ops/sec [4,152..4,336]	🟢 +66.2%
filter(x => x > 50)	3,227 ops/sec [3,147..3,276] → 1,964 ops/sec [1,950..1,971]	🔴 -39.1%	2,793 ops/sec [2,669..2,911] → 2,907 ops/sec [2,811..4,547]	~ overlap (+4.1%)
reduce (sum)	3,164 ops/sec [3,141..3,192] → 1,928 ops/sec [1,924..1,932]	🔴 -39.1%	2,536 ops/sec [2,342..2,570] → 2,616 ops/sec [2,541..2,636]	~ overlap (+3.2%)
sort()	37,607 ops/sec [37,344..37,675] → 20,810 ops/sec [20,655..21,919]	🔴 -44.7%	26,505 ops/sec [24,927..28,969] → 28,493 ops/sec [27,725..29,208]	~ overlap (+7.5%)
indexOf()	45,274 ops/sec [44,817..45,557] → 27,151 ops/sec [26,652..29,061]	🔴 -40.0%	32,600 ops/sec [31,402..33,723] → 37,862 ops/sec [37,427..38,097]	🟢 +16.1%
reverse()	46,468 ops/sec [45,844..46,805] → 46,501 ops/sec [46,374..46,529]	~ overlap (+0.1%)	31,277 ops/sec [27,822..33,293] → 34,224 ops/sec [33,400..34,838]	🟢 +9.4%
create view over existing buffer	194,381 ops/sec [189,080..195,571] → 195,160 ops/sec [191,947..195,392]	~ overlap (+0.4%)	214,388 ops/sec [206,554..221,381] → 353,686 ops/sec [340,112..362,211]	🟢 +65.0%
subarray()	93,462 ops/sec [92,957..93,671] → 93,218 ops/sec [92,484..94,289]	~ overlap (-0.3%)	90,039 ops/sec [88,142..94,101] → 145,799 ops/sec [144,166..149,307]	🟢 +61.9%
set() from array	107,024 ops/sec [106,624..107,281] → 93,968 ops/sec [93,467..94,938]	🔴 -12.2%	92,676 ops/sec [89,697..94,372] → 160,479 ops/sec [156,971..161,571]	🟢 +73.2%
for-of loop	2,188 ops/sec [2,152..2,197] → 2,139 ops/sec [2,119..2,172]	~ overlap (-2.2%)	12,262 ops/sec [11,973..12,831] → 21,308 ops/sec [21,087..21,371]	🟢 +73.8%
spread into array	8,703 ops/sec [8,635..8,791] → 9,131 ops/sec [9,046..9,255]	🟢 +4.9%	33,991 ops/sec [33,249..34,909] → 36,084 ops/sec [35,298..36,553]	🟢 +6.2%

uint8array-encoding.js — Interp: 🟢 4, 🔴 1, 13 unch. · avg +17.4% · Bytecode: 🟢 8, 🔴 2, 8 unch. · avg +4.3%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
short (5 bytes)	128,881 ops/sec [126,122..130,649] → 124,401 ops/sec [122,777..127,611]	~ overlap (-3.5%)	200,872 ops/sec [195,204..225,611] → 218,744 ops/sec [214,363..221,853]	~ overlap (+8.9%)
medium (450 bytes)	86,355 ops/sec [85,693..87,434] → 86,239 ops/sec [84,576..87,106]	~ overlap (-0.1%)	129,524 ops/sec [127,050..132,073] → 133,386 ops/sec [126,977..139,449]	~ overlap (+3.0%)
large (4096 bytes)	23,947 ops/sec [23,815..24,108] → 23,588 ops/sec [23,393..23,829]	~ overlap (-1.5%)	33,364 ops/sec [33,038..33,513] → 34,071 ops/sec [31,353..35,352]	~ overlap (+2.1%)
base64url alphabet	65,986 ops/sec [65,213..67,908] → 66,279 ops/sec [63,852..70,963]	~ overlap (+0.4%)	81,948 ops/sec [80,033..82,291] → 90,321 ops/sec [89,431..92,204]	🟢 +10.2%
omitPadding	88,295 ops/sec [86,898..91,020] → 87,587 ops/sec [86,058..89,326]	~ overlap (-0.8%)	117,760 ops/sec [115,021..120,613] → 128,306 ops/sec [121,229..132,941]	🟢 +9.0%
short (8 chars)	96,704 ops/sec [95,821..97,126] → 94,570 ops/sec [93,367..95,981]	~ overlap (-2.2%)	127,501 ops/sec [125,515..132,405] → 139,750 ops/sec [134,847..147,634]	🟢 +9.6%
medium (600 chars)	18,957 ops/sec [18,874..19,627] → 19,098 ops/sec [18,378..19,223]	~ overlap (+0.7%)	24,805 ops/sec [23,572..37,338] → 27,018 ops/sec [25,311..27,804]	~ overlap (+8.9%)
large (5464 chars)	2,530 ops/sec [2,504..2,587] → 2,510 ops/sec [2,489..2,555]	~ overlap (-0.8%)	5,110 ops/sec [4,766..5,306] → 3,576 ops/sec [3,422..3,625]	🔴 -30.0%
short (5 bytes)	128,617 ops/sec [128,171..134,269] → 208,939 ops/sec [205,464..209,532]	🟢 +62.4%	319,939 ops/sec [315,748..330,946] → 221,512 ops/sec [216,789..224,409]	🔴 -30.8%
medium (450 bytes)	129,003 ops/sec [128,629..130,276] → 128,755 ops/sec [127,631..128,902]	~ overlap (-0.2%)	117,248 ops/sec [115,124..118,464] → 121,795 ops/sec [118,102..124,588]	~ overlap (+3.9%)
large (4096 bytes)	32,285 ops/sec [32,025..32,498] → 18,825 ops/sec [18,723..19,190]	🔴 -41.7%	26,394 ops/sec [24,510..27,327] → 27,238 ops/sec [26,557..27,496]	~ overlap (+3.2%)
short (10 chars)	169,156 ops/sec [158,275..170,742] → 158,479 ops/sec [104,336..169,820]	~ overlap (-6.3%)	153,239 ops/sec [150,162..229,830] → 237,171 ops/sec [233,622..239,846]	🟢 +54.8%
medium (900 chars)	79,512 ops/sec [78,307..132,188] → 132,287 ops/sec [130,840..133,078]	~ overlap (+66.4%)	167,104 ops/sec [159,822..167,305] → 174,091 ops/sec [170,403..179,074]	🟢 +4.2%
large (8192 chars)	47,524 ops/sec [47,098..47,976] → 46,496 ops/sec [46,293..47,221]	~ overlap (-2.2%)	51,046 ops/sec [50,300..52,186] → 54,846 ops/sec [54,324..55,985]	🟢 +7.4%
setFromBase64 (450 bytes)	20,514 ops/sec [17,969..31,253] → 31,137 ops/sec [30,937..31,172]	~ overlap (+51.8%)	37,665 ops/sec [34,631..39,224] → 39,242 ops/sec [38,315..40,248]	~ overlap (+4.2%)
setFromHex (450 bytes)	21,183 ops/sec [20,755..25,053] → 34,968 ops/sec [34,823..35,332]	🟢 +65.1%	36,846 ops/sec [34,897..37,442] → 38,595 ops/sec [38,170..38,991]	🟢 +4.7%
toBase64 → fromBase64 (450 bytes)	16,444 ops/sec [16,288..16,683] → 27,903 ops/sec [27,803..27,959]	🟢 +69.7%	34,298 ops/sec [33,852..34,585] → 35,271 ops/sec [34,798..36,050]	🟢 +2.8%
toHex → fromHex (450 bytes)	47,493 ops/sec [46,846..49,481] → 73,836 ops/sec [72,616..75,169]	🟢 +55.5%	95,367 ops/sec [89,407..96,454] → 96,752 ops/sec [95,000..99,047]	~ overlap (+1.5%)

weak-collections.js — Interp: 🟢 3, 12 unch. · avg +8.8% · Bytecode: 🟢 7, 🔴 4, 4 unch. · avg +10.7%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
constructor from 50 entries	7,802 ops/sec [7,574..7,910] → 7,778 ops/sec [7,657..8,523]	~ overlap (-0.3%)	9,595 ops/sec [9,385..9,696] → 11,097 ops/sec [10,633..11,519]	🟢 +15.6%
set 50 object keys	2,526 ops/sec [2,475..2,571] → 2,638 ops/sec [2,599..2,650]	🟢 +4.4%	4,142 ops/sec [4,075..4,199] → 4,387 ops/sec [4,064..4,527]	~ overlap (+5.9%)
get lookups (50 entries)	34,462 ops/sec [34,265..35,538] → 34,757 ops/sec [34,686..34,783]	~ overlap (+0.9%)	89,931 ops/sec [86,959..91,567] → 95,840 ops/sec [94,669..96,042]	🟢 +6.6%
has checks (50 entries)	45,142 ops/sec [43,980..46,999] → 73,243 ops/sec [72,858..73,889]	🟢 +62.3%	170,520 ops/sec [163,080..172,569] → 122,779 ops/sec [122,729..122,887]	🔴 -28.0%
delete entries	2,347 ops/sec [2,319..2,427] → 3,808 ops/sec [3,559..3,840]	🟢 +62.3%	6,207 ops/sec [6,167..6,291] → 4,238 ops/sec [4,127..4,262]	🔴 -31.7%
non-registered symbol keys	5,706 ops/sec [5,668..5,728] → 5,761 ops/sec [5,712..5,799]	~ overlap (+1.0%)	15,563 ops/sec [15,081..15,894] → 10,059 ops/sec [9,713..10,198]	🔴 -35.4%
getOrInsert	2,225 ops/sec [2,190..2,260] → 2,219 ops/sec [2,198..2,284]	~ overlap (-0.3%)	5,974 ops/sec [5,822..6,038] → 4,071 ops/sec [3,944..4,203]	🔴 -31.8%
getOrInsertComputed	1,382 ops/sec [1,373..1,389] → 1,402 ops/sec [1,389..1,465]	~ overlap (+1.4%)	2,050 ops/sec [1,876..2,159] → 2,229 ops/sec [2,126..2,266]	~ overlap (+8.7%)
forced gc live-key retention	766 ops/sec [741..1,000] → 949 ops/sec [923..984]	~ overlap (+23.8%)	1,219 ops/sec [997..1,384] → 1,258 ops/sec [1,191..1,316]	~ overlap (+3.1%)
constructor from 50 values	9,504 ops/sec [9,197..9,623] → 9,272 ops/sec [9,081..9,565]	~ overlap (-2.4%)	12,257 ops/sec [12,159..12,330] → 13,009 ops/sec [12,682..13,205]	🟢 +6.1%
add 50 object values	2,675 ops/sec [2,668..2,679] → 2,675 ops/sec [2,659..2,701]	~ overlap (+0.0%)	4,565 ops/sec [4,086..4,776] → 7,385 ops/sec [7,197..7,641]	🟢 +61.8%
has checks (50 values)	76,465 ops/sec [45,914..77,243] → 74,572 ops/sec [74,287..76,141]	~ overlap (-2.5%)	117,100 ops/sec [112,816..121,167] → 185,860 ops/sec [179,900..189,262]	🟢 +58.7%
delete values	12,174 ops/sec [11,697..12,258] → 12,146 ops/sec [12,017..12,173]	~ overlap (-0.2%)	11,240 ops/sec [10,972..11,369] → 17,980 ops/sec [17,068..18,148]	🟢 +60.0%
non-registered symbol values	9,707 ops/sec [9,665..9,752] → 9,787 ops/sec [9,718..9,836]	~ overlap (+0.8%)	10,584 ops/sec [10,437..10,766] → 16,809 ops/sec [16,479..17,364]	🟢 +58.8%
forced gc pruning smoke	1,738 ops/sec [1,287..1,768] → 1,405 ops/sec [1,363..1,817]	~ overlap (-19.2%)	1,914 ops/sec [1,866..1,949] → 1,959 ops/sec [1,917..1,964]	~ overlap (+2.3%)

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]

AWFY Results

Target	Status	Goccia main	Goccia PR	QuickJS 2026-06-04	NodeJS v26.5.0	Δ PR vs main
Bounce	pass	23.97ms	23.88ms	1.04ms	1.06ms	~ overlap (+0.37%)
CD	pass	219.68ms	220.04ms	10.72ms	9.62ms	~ overlap (-0.16%)
DeltaBlue	pass	5.05ms	5.09ms	310.26µs	1.78ms	~ overlap (-0.69%)
Havlak	pass	86.05s	85.95s	4282.01ms	180.89ms	~ overlap (+0.12%)
Json	pass	370.68ms	370.33ms	14.42ms	4.68ms	~ overlap (+0.10%)
List	pass	16.75ms	17.40ms	1.04ms	0.73ms	~ overlap (-3.92%)
Mandelbrot	pass	31.30µs	31.09µs	4.96µs	89.88µs	~ overlap (+0.67%)
NBody	pass	392.50µs	391.60µs	28.49µs	387.02µs	~ overlap (+0.23%)
Permute	pass	45.83ms	45.58ms	1.95ms	0.72ms	~ overlap (+0.54%)
Queens	pass	24.54ms	24.63ms	1.25ms	1.01ms	~ overlap (-0.38%)
Richards	pass	1002.63ms	1001.31ms	51.63ms	7.28ms	~ overlap (+0.13%)
Sieve	pass	14.41ms	14.50ms	0.56ms	0.76ms	~ overlap (-0.62%)
Storage	pass	37.27ms	37.17ms	2.91ms	0.98ms	~ overlap (+0.28%)
Towers	pass	65.77ms	65.44ms	3.15ms	1.13ms	~ overlap (+0.49%)

Geomean Ratios

Ratio (row / column)	Goccia main	Goccia PR	QuickJS 2026-06-04	NodeJS v26.5.0
Goccia main	1.000	0.998	17.894	21.299
Goccia PR	1.002	1.000	17.929	21.341
QuickJS 2026-06-04	0.056	0.056	1.000	1.190
NodeJS v26.5.0	0.047	0.047	0.840	1.000

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

[github-actions]

test262 Conformance

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

Category	Run	Passed	Δ Pass	Failed	Timeouts	Δ Timeout	Wrap-Infra	Pass-rate	Δ Rate
built-ins	23,668	23,668	±0	0	0	±0	0	100.0%	±0pp
harness	116	116	±0	0	0	±0	0	100.0%	±0pp
intl402	3,349	3,340	±0	8	1	±0	0	99.7%	±0pp
language	23,713	23,710	±0	1	2	±0	0	100.0%	±0pp
staging	1,482	1,386	+2	86	10	-2	0	93.5%	+0.1pp
total	52,328	52,220	+2	95	13	-2	0	99.8%	±0pp

Areas closest to 100%

Area	Pass rate	Δ vs main	Passing
language/expressions	100.0%	±0pp	11,101 / 11,102
intl402/Temporal	100.0%	±0pp	2,028 / 2,029
intl402/NumberFormat	99.6%	±0pp	248 / 249

Per-test deltas (+0 / -0 / timeout +0 / -2)

Resolved timeouts (2):

• staging/sm/extensions/recursion.js
• staging/sm/TypedArray/element-setting-converts-using-ToNumber.js

_{Steady-state failures and timeouts are non-blocking; PASS → non-timeout failure transitions fail the conformance gate. Measured on ubuntu-latest x64, bytecode mode. Areas grouped by the first two test262 path components; minimum 25 attempted tests, areas already at 100% excluded. Δ vs main compares against the most recent cached main baseline.}