perf(array): reuse live callback argument roots

[frostney]

Summary

• Remove redundant root allocation and temporary-root bookkeeping from array callback dispatch. Existing live argument containers already trace the callback, receiver, element, index, source array, and reduce accumulator under ADR 0105. Keep generator-continuation restoration and every result root intact.
• Add a nested Proxy callback/explicit-GC/exception regression and a verified map/reduce probe. Document the existing ownership contract and record the accepted experiment in the runtime handoff. Separate source review checked all 26 dispatch sites, argument-pool lifetimes, specialized root tracing, and nested calls.
• Production macOS arm64/FPC 3.2.2 measurements against f33d9c6a061e6cb61dce65ffcf8514da1c051870: the focused 128-value map/reduce workload improves about 21% in both AB/BA orders. Full verified upstream AWFY NBody improves from 17.014174 s to 16.523542 s in execution time (2.88%); separate process CPU improves 2.59%, with disjoint ranges and improvement in every ABBA block. Richards remains neutral. These are individual workload results, not an aggregate suite score.
• Two earlier active-root-frame candidates were rejected because their probe gains did not establish representative transfer. The accepted change removes the redundant work entirely using source-verified existing ownership; no value cache or VM-specific array path is added.

Testing

• Verified no regressions and confirmed the change in end-to-end JavaScript tests — full production and checked-development interpreter/bytecode suites each pass 12,819 tests / 28,580 assertions across 1,615 files (--jobs=2). Focused Array and callback suites pass 592 tests / 1,170 assertions per executor.
• Updated documentation — GC ownership guide and benchmark handoff, including baseline/candidate identity, measured spread, rejected experiments, and remaining costs.
• Optional: Native Pascal validation — checked GC suite passes 12/12; clean development testrunner and production loader/testrunner/FFI builds pass.
• Optional: Performance validation — production binaries, independent checksum/upstream verifiers, one discarded warmup, seven measured samples per binary in both AB/BA orders for target and guards; full NBody confirmation uses four ABBA blocks and eight samples per binary. AWFY pin: 74306fec151070fd07157cefeacf19e7e0bcdc89.

Formatter passes all 463 Pascal files, the AWFY driver checks pass 59 assertions, and ordinary hooks pass. Exact-head CI is pending; the PR remains draft until it completes. No combined-optimization or cross-architecture speedup is claimed.

[vercel]

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

1 Skipped Deployment

Project	Deployment	Actions	Updated
gocciascript-homepage	Ignored	Preview	Sep 4, 2026 11:39pm UTC

[coderabbitai]

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Team

Run ID: 193832a5-b2e4-4314-952a-33735664205a

📥 Commits

Reviewing files that changed from the base of the PR and between f33d9c6 and 2f0939d.

📒 Files selected for processing (6)

• .agent/HANDOFF.md
• docs/garbage-collector.md
• perf/awfy/manifest.json
• perf/probes/array-callbacks.js
• source/units/Goccia.Values.ArrayValue.pas
• tests/built-ins/callback-gc-roots.js

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

---

📝 Walkthrough

Walkthrough

Array callback dispatch now relies on argument collections for callback-related GC roots instead of per-call temporary roots. Generator restoration remains exception-safe. Documentation, regression coverage, benchmark configuration, and audit evidence were added.

Changes

Array callback root optimization

Layer / File(s)	Summary
Callback root ownership and dispatch source/units/Goccia.Values.ArrayValue.pas, docs/garbage-collector.md, tests/built-ins/callback-gc-roots.js	InvokeArrayCallback removes temporary root allocation and uses argument collections for live callback values. Generator continuation restoration remains protected by finally. Documentation and regression tests cover nested callbacks, explicit garbage collection, receivers, arguments, errors, and array access.
Performance probe and audit evidence perf/probes/array-callbacks.js, perf/awfy/manifest.json, .agent/HANDOFF.md	A deterministic map/reduce probe and manifest entry measure array callbacks. The audit records the implementation model, benchmark data, rejected alternatives, and validation status.

Estimated code review effort: 3 (Moderate) | ~20 minutes

Merge Risk: ⚪ Minimal · up to 2f093

Array callback dispatch now reuses live argument roots while preserving callback behavior and generator restoration. No current merge-blocking risk remains.

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title clearly and concisely describes the main change: reusing live callback argument roots for array performance.
Description check	✅ Passed	The description includes the required Summary and Testing sections. It explains the implementation, constraints, validation results, documentation updates, performance coverage, and pending CI status.…
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check. Docstring coverage is scoped to functions touched by this diff. Analyzed 0 functions across 2…
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.

---

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

[github-actions]

Web Tooling Benchmark

Workload	Status	Goccia
acorn	pass	0.02 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.08 runs/s
coffeescript	pass	0.01 runs/s
espree	pass	0.02 runs/s
esprima	pass	0.06 runs/s
jshint	pass	0.01 runs/s
lebab	pass	0.07 runs/s
postcss	pass	0.02 runs/s
prepack	pass	0.12 runs/s
prettier	pass	0.07 runs/s
source-map	pass	0.04 runs/s
terser	pass	0.25 runs/s
typescript	pass	0.11 runs/s
uglify-js	pass	0.05 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.80	0.80	18.57	404.38	23.36×	508.46×
ai-astar	pass	1.79	1.80	42.25	343.42	23.46×	190.71×
gaussian-blur	pass	0.29	0.37	7.89	306.91	21.51×	836.89×
raytrace-public-class-fields	pass	0.42	0.41	10.96	186.46	26.48×	450.45×
sync-fs	pass	1.22	1.22	39.93	272.74	32.80×	224.00×
lazy-collections	pass	2.19	2.17	69.04	150.67	31.81×	69.43×

Geomean reference ratio: QuickJS 26.23×; Node.js 287.82×.

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

Benchmark Results

440 benchmarks · PR vs same-runner main build

Interpreted: 🟢 63 improved · 🔴 18 regressed · 359 unchanged · avg +1.6%
Bytecode: 🟢 92 improved · 🔴 19 regressed · 329 unchanged · avg +3.2%

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

arraybuffer.js — Interp: 14 unch. · avg +0.8% · Bytecode: 🟢 7, 7 unch. · avg +1.8%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
create ArrayBuffer(0)	79,029 ops/sec [76,596..81,637] → 78,272 ops/sec [69,813..82,899]	~ overlap (-1.0%)	141,282 ops/sec [139,955..142,614] → 141,016 ops/sec [139,097..141,851]	~ overlap (-0.2%)
create ArrayBuffer(64)	76,692 ops/sec [75,463..80,539] → 76,767 ops/sec [72,686..77,228]	~ overlap (+0.1%)	133,804 ops/sec [131,645..154,668] → 133,367 ops/sec [133,099..161,786]	~ overlap (-0.3%)
create ArrayBuffer(1024)	73,858 ops/sec [69,920..77,380] → 77,492 ops/sec [71,450..95,112]	~ overlap (+4.9%)	119,571 ops/sec [118,526..119,819] → 120,453 ops/sec [118,532..142,616]	~ overlap (+0.7%)
create ArrayBuffer(8192)	52,861 ops/sec [51,409..58,528] → 52,366 ops/sec [50,183..55,088]	~ overlap (-0.9%)	69,879 ops/sec [69,446..70,577] → 68,655 ops/sec [68,308..71,380]	~ overlap (-1.8%)
slice full buffer (64 bytes)	62,989 ops/sec [57,640..67,166] → 64,916 ops/sec [61,201..77,078]	~ overlap (+3.1%)	86,191 ops/sec [64,066..87,634] → 87,856 ops/sec [86,619..88,433]	~ overlap (+1.9%)
slice half buffer (512 of 1024 bytes)	59,874 ops/sec [58,092..60,723] → 58,788 ops/sec [57,319..60,622]	~ overlap (-1.8%)	82,889 ops/sec [82,565..83,012] → 83,447 ops/sec [83,110..94,675]	🟢 +0.7%
slice with negative indices	56,111 ops/sec [53,924..58,351] → 57,173 ops/sec [56,701..58,509]	~ overlap (+1.9%)	82,615 ops/sec [82,068..83,142] → 84,175 ops/sec [84,046..85,172]	🟢 +1.9%
slice empty range	62,173 ops/sec [61,508..67,260] → 60,758 ops/sec [58,667..65,532]	~ overlap (-2.3%)	85,149 ops/sec [83,870..85,874] → 86,533 ops/sec [86,128..91,562]	🟢 +1.6%
byteLength access	172,271 ops/sec [170,872..183,146] → 178,943 ops/sec [177,249..210,292]	~ overlap (+3.9%)	252,875 ops/sec [252,617..253,673] → 268,859 ops/sec [265,677..292,494]	🟢 +6.3%
Symbol.toStringTag access	177,393 ops/sec [176,250..178,901] → 180,583 ops/sec [176,557..206,379]	~ overlap (+1.8%)	257,146 ops/sec [256,989..260,344] → 266,580 ops/sec [265,510..319,874]	🟢 +3.7%
ArrayBuffer.isView	133,826 ops/sec [133,532..142,485] → 133,389 ops/sec [130,706..148,109]	~ overlap (-0.3%)	201,680 ops/sec [201,271..203,703] → 208,146 ops/sec [207,140..210,618]	🟢 +3.2%
clone ArrayBuffer(64)	99,758 ops/sec [98,098..103,075] → 99,714 ops/sec [98,673..106,528]	~ overlap (-0.0%)	143,738 ops/sec [143,403..143,856] → 150,341 ops/sec [145,043..163,004]	🟢 +4.6%
clone ArrayBuffer(1024)	90,420 ops/sec [89,368..91,257] → 91,531 ops/sec [88,466..91,796]	~ overlap (+1.2%)	127,772 ops/sec [125,900..131,569] → 129,033 ops/sec [126,077..130,055]	~ overlap (+1.0%)
clone ArrayBuffer inside object	61,282 ops/sec [58,800..62,609] → 61,930 ops/sec [61,796..62,050]	~ overlap (+1.1%)	82,563 ops/sec [82,339..82,745] → 83,838 ops/sec [82,643..115,240]	~ overlap (+1.5%)

arrays.js — Interp: 🟢 11, 🔴 1, 7 unch. · avg +9.7% · Bytecode: 🟢 11, 8 unch. · avg +14.6%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Array.from length 100	2,196 ops/sec [2,161..2,438] → 2,016 ops/sec [1,872..2,086]	🔴 -8.2%	2,243 ops/sec [2,215..2,253] → 2,405 ops/sec [2,243..2,517]	~ overlap (+7.2%)
Array.from 10 elements	13,463 ops/sec [9,171..16,173] → 13,242 ops/sec [12,060..17,369]	~ overlap (-1.6%)	16,199 ops/sec [15,961..17,436] → 15,775 ops/sec [15,664..17,761]	~ overlap (-2.6%)
Array.of 10 elements	41,505 ops/sec [41,457..42,986] → 41,467 ops/sec [40,836..41,892]	~ overlap (-0.1%)	57,810 ops/sec [57,637..60,684] → 58,018 ops/sec [57,132..59,972]	~ overlap (+0.4%)
spread into new array	70,631 ops/sec [67,437..77,950] → 65,094 ops/sec [62,122..67,560]	~ overlap (-7.8%)	47,356 ops/sec [45,269..55,965] → 46,568 ops/sec [45,904..53,686]	~ overlap (-1.7%)
map over 50 elements	3,962 ops/sec [3,678..4,450] → 4,115 ops/sec [4,025..4,199]	~ overlap (+3.9%)	4,892 ops/sec [4,698..5,047] → 5,771 ops/sec [5,700..5,862]	🟢 +18.0%
filter over 50 elements	3,851 ops/sec [3,828..3,897] → 4,355 ops/sec [4,049..4,584]	🟢 +13.1%	5,206 ops/sec [5,117..5,295] → 6,339 ops/sec [6,319..6,388]	🟢 +21.8%
reduce sum 50 elements	4,628 ops/sec [4,435..4,824] → 5,650 ops/sec [5,373..5,967]	🟢 +22.1%	5,518 ops/sec [5,464..5,792] → 7,424 ops/sec [7,411..7,461]	🟢 +34.5%
forEach over 50 elements	3,254 ops/sec [3,235..3,385] → 3,645 ops/sec [3,571..3,791]	🟢 +12.0%	6,005 ops/sec [5,928..6,065] → 7,875 ops/sec [7,857..7,883]	🟢 +31.1%
find in 50 elements	6,347 ops/sec [6,306..6,676] → 7,845 ops/sec [7,674..8,969]	🟢 +23.6%	7,563 ops/sec [7,326..8,291] → 9,801 ops/sec [9,731..9,843]	🟢 +29.6%
sort 20 elements	3,450 ops/sec [3,416..3,477] → 3,682 ops/sec [3,338..4,269]	~ overlap (+6.7%)	4,299 ops/sec [4,278..4,388] → 4,381 ops/sec [4,343..5,068]	~ overlap (+1.9%)
flat nested array	24,407 ops/sec [23,952..28,149] → 24,581 ops/sec [24,380..27,396]	~ overlap (+0.7%)	32,450 ops/sec [31,775..32,529] → 33,530 ops/sec [31,552..36,179]	~ overlap (+3.3%)
flatMap	14,557 ops/sec [14,432..16,465] → 15,882 ops/sec [15,768..15,946]	~ overlap (+9.1%)	19,449 ops/sec [18,796..19,942] → 20,751 ops/sec [20,489..22,852]	🟢 +6.7%
map inside map (5x5)	4,288 ops/sec [4,267..4,348] → 4,898 ops/sec [4,777..5,060]	🟢 +14.2%	5,739 ops/sec [5,266..6,585] → 6,370 ops/sec [6,141..7,383]	~ overlap (+11.0%)
filter inside map (5x10)	2,837 ops/sec [2,816..2,937] → 3,301 ops/sec [3,271..3,353]	🟢 +16.4%	3,768 ops/sec [3,753..3,806] → 4,438 ops/sec [4,356..4,596]	🟢 +17.8%
reduce inside map (5x10)	3,578 ops/sec [3,489..3,587] → 4,431 ops/sec [4,312..4,506]	🟢 +23.9%	4,431 ops/sec [4,392..4,455] → 5,514 ops/sec [5,410..5,598]	🟢 +24.4%
forEach inside forEach (5x10)	2,777 ops/sec [2,721..3,048] → 3,135 ops/sec [3,103..3,683]	🟢 +12.9%	4,937 ops/sec [4,795..4,976] → 6,116 ops/sec [5,945..7,070]	🟢 +23.9%
find inside some (10x10)	2,819 ops/sec [2,751..2,841] → 3,346 ops/sec [3,323..3,436]	🟢 +18.7%	3,363 ops/sec [3,308..3,406] → 4,258 ops/sec [4,224..4,267]	🟢 +26.6%
map+filter chain nested (5x20)	882 ops/sec [855..1,010] → 1,020 ops/sec [1,011..1,123]	🟢 +15.7%	1,128 ops/sec [1,099..1,158] → 1,357 ops/sec [1,347..1,360]	🟢 +20.2%
reduce flatten (10x5)	6,492 ops/sec [6,368..6,508] → 7,041 ops/sec [7,012..9,656]	🟢 +8.5%	3,160 ops/sec [3,069..3,236] → 3,237 ops/sec [3,182..3,270]	~ overlap (+2.4%)

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

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
single await	18,409 ops/sec [18,192..18,692] → 18,392 ops/sec [17,216..21,922]	~ overlap (-0.1%)	25,774 ops/sec [25,751..25,843] → 25,323 ops/sec [20,415..31,012]	~ overlap (-1.8%)
multiple awaits	7,536 ops/sec [7,398..8,350] → 7,489 ops/sec [7,124..8,105]	~ overlap (-0.6%)	9,139 ops/sec [8,894..9,697] → 9,164 ops/sec [9,109..9,240]	~ overlap (+0.3%)
await non-Promise value	25,390 ops/sec [24,420..25,903] → 26,125 ops/sec [25,797..26,288]	~ overlap (+2.9%)	38,421 ops/sec [38,161..40,918] → 38,989 ops/sec [37,485..43,450]	~ overlap (+1.5%)
await with try/catch	16,802 ops/sec [15,049..17,885] → 17,150 ops/sec [16,545..19,830]	~ overlap (+2.1%)	25,838 ops/sec [25,269..29,653] → 25,877 ops/sec [25,351..26,537]	~ overlap (+0.2%)
await Promise.all	4,371 ops/sec [4,331..4,414] → 4,335 ops/sec [4,143..4,342]	~ overlap (-0.8%)	5,349 ops/sec [5,332..5,407] → 5,430 ops/sec [5,347..5,439]	~ overlap (+1.5%)
nested async function call	9,735 ops/sec [9,405..10,858] → 10,387 ops/sec [9,680..10,725]	~ overlap (+6.7%)	13,145 ops/sec [12,424..13,362] → 15,159 ops/sec [14,809..15,246]	🟢 +15.3%

async-generators.js — Interp: 2 unch. · avg -7.9% · Bytecode: 2 unch. · avg +4.8%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for-await-of over async generator	1,370 ops/sec [1,226..1,558] → 1,164 ops/sec [1,007..1,471]	~ overlap (-15.1%)	624 ops/sec [600..629] → 634 ops/sec [595..662]	~ overlap (+1.6%)
async generator with await in body	4,880 ops/sec [3,678..5,716] → 4,848 ops/sec [4,655..4,959]	~ overlap (-0.7%)	4,833 ops/sec [4,718..6,080] → 5,224 ops/sec [4,759..5,633]	~ overlap (+8.1%)

atomics.js — Interp: 6 unch. · avg -0.4% · Bytecode: 🟢 2, 4 unch. · avg +1.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
load and store Int32Array	65,060 ops/sec [64,791..68,789] → 66,981 ops/sec [66,672..68,095]	~ overlap (+3.0%)	106,024 ops/sec [105,128..106,747] → 107,891 ops/sec [107,163..111,469]	🟢 +1.8%
read-modify-write Int32Array	49,469 ops/sec [44,078..60,100] → 49,828 ops/sec [48,084..50,439]	~ overlap (+0.7%)	72,559 ops/sec [71,427..74,665] → 74,248 ops/sec [73,213..79,650]	~ overlap (+2.3%)
compareExchange hit and miss	46,719 ops/sec [46,529..47,496] → 45,516 ops/sec [41,259..46,550]	~ overlap (-2.6%)	68,285 ops/sec [61,657..69,881] → 69,948 ops/sec [68,507..81,984]	~ overlap (+2.4%)
wait with zero timeout	109,733 ops/sec [107,942..110,446] → 110,865 ops/sec [108,305..113,770]	~ overlap (+1.0%)	174,828 ops/sec [174,145..176,142] → 178,497 ops/sec [177,573..179,190]	🟢 +2.1%
waitAsync synchronous not-equal	79,673 ops/sec [77,252..84,982] → 78,812 ops/sec [72,505..81,584]	~ overlap (-1.1%)	115,486 ops/sec [112,059..121,332] → 115,601 ops/sec [115,292..116,461]	~ overlap (+0.1%)
notify with no waiters	112,398 ops/sec [103,500..122,174] → 108,726 ops/sec [105,272..113,365]	~ overlap (-3.3%)	178,412 ops/sec [174,387..181,490] → 177,749 ops/sec [176,948..178,681]	~ overlap (-0.4%)

base64.js — Interp: 🟢 4, 6 unch. · avg +4.0% · Bytecode: 🟢 3, 7 unch. · avg +2.5%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
short ASCII (13 chars)	1,877 ops/sec [1,850..1,896] → 1,990 ops/sec [1,974..2,007]	🟢 +6.0%	2,128 ops/sec [2,099..2,138] → 2,231 ops/sec [2,218..2,235]	🟢 +4.8%
medium ASCII (450 chars)	68 ops/sec [68..69] → 73 ops/sec [73..73]	🟢 +6.7%	77 ops/sec [76..77] → 82 ops/sec [81..83]	🟢 +7.3%
Latin-1 characters	2,750 ops/sec [2,724..2,793] → 2,831 ops/sec [2,726..2,872]	~ overlap (+2.9%)	3,090 ops/sec [3,057..3,126] → 3,281 ops/sec [3,230..3,300]	🟢 +6.2%
short base64 (20 chars)	1,428 ops/sec [1,407..1,436] → 1,400 ops/sec [1,382..1,429]	~ overlap (-2.0%)	1,595 ops/sec [1,591..1,596] → 1,580 ops/sec [1,561..1,598]	~ overlap (-0.9%)
medium base64 (600 chars)	56 ops/sec [52..61] → 55 ops/sec [55..56]	~ overlap (-1.2%)	62 ops/sec [62..62] → 63 ops/sec [61..63]	~ overlap (+0.6%)
Latin-1 output	1,949 ops/sec [1,904..2,064] → 2,001 ops/sec [1,986..2,020]	~ overlap (+2.7%)	2,268 ops/sec [2,237..2,284] → 2,308 ops/sec [2,254..2,676]	~ overlap (+1.8%)
forgiving (no padding)	2,879 ops/sec [2,826..2,895] → 2,981 ops/sec [2,867..3,686]	~ overlap (+3.6%)	3,347 ops/sec [3,301..3,374] → 3,387 ops/sec [3,371..3,448]	~ overlap (+1.2%)
with whitespace	1,424 ops/sec [1,333..1,521] → 1,396 ops/sec [1,377..1,473]	~ overlap (-2.0%)	1,588 ops/sec [1,530..1,697] → 1,579 ops/sec [1,564..1,583]	~ overlap (-0.6%)
atob(btoa(short))	813 ops/sec [807..818] → 892 ops/sec [839..1,064]	🟢 +9.8%	898 ops/sec [885..1,269] → 927 ops/sec [916..1,356]	~ overlap (+3.2%)
atob(btoa(medium))	30 ops/sec [30..31] → 34 ops/sec [31..36]	🟢 +13.1%	35 ops/sec [34..37] → 36 ops/sec [35..38]	~ overlap (+1.4%)

classes.js — Interp: 🟢 2, 29 unch. · avg +0.0% · Bytecode: 🟢 3, 28 unch. · avg +0.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple class new	30,112 ops/sec [29,613..31,798] → 30,786 ops/sec [29,092..34,929]	~ overlap (+2.2%)	53,235 ops/sec [53,226..53,401] → 54,149 ops/sec [53,670..55,352]	🟢 +1.7%
class with defaults	24,227 ops/sec [23,897..24,250] → 23,596 ops/sec [22,750..24,432]	~ overlap (-2.6%)	39,099 ops/sec [38,876..39,185] → 40,053 ops/sec [37,952..46,737]	~ overlap (+2.4%)
50 instances via Array.from	1,035 ops/sec [1,031..1,038] → 1,030 ops/sec [1,019..1,034]	~ overlap (-0.4%)	1,508 ops/sec [1,504..1,519] → 1,501 ops/sec [1,482..1,504]	~ overlap (-0.4%)
instance method call	14,092 ops/sec [13,976..14,286] → 14,306 ops/sec [14,053..15,826]	~ overlap (+1.5%)	31,502 ops/sec [30,701..31,731] → 32,121 ops/sec [31,815..32,330]	🟢 +2.0%
static method call	24,325 ops/sec [23,912..24,931] → 24,760 ops/sec [24,226..25,069]	~ overlap (+1.8%)	62,454 ops/sec [60,059..67,663] → 60,951 ops/sec [60,010..66,590]	~ overlap (-2.4%)
single-level inheritance	11,894 ops/sec [11,821..12,174] → 12,339 ops/sec [12,044..14,982]	~ overlap (+3.7%)	20,248 ops/sec [19,130..20,644] → 20,680 ops/sec [20,449..21,312]	~ overlap (+2.1%)
two-level inheritance	11,474 ops/sec [10,540..13,088] → 10,794 ops/sec [10,614..11,846]	~ overlap (-5.9%)	16,135 ops/sec [15,970..16,237] → 16,194 ops/sec [15,442..16,222]	~ overlap (+0.4%)
private field access	15,445 ops/sec [15,224..15,760] → 15,449 ops/sec [15,116..16,817]	~ overlap (+0.0%)	13,191 ops/sec [13,042..13,375] → 13,182 ops/sec [13,037..14,693]	~ overlap (-0.1%)
private methods	16,759 ops/sec [16,555..19,151] → 16,939 ops/sec [16,830..19,012]	~ overlap (+1.1%)	13,809 ops/sec [13,750..13,978] → 13,899 ops/sec [13,769..13,960]	~ overlap (+0.7%)
getter/setter access	16,225 ops/sec [16,066..16,626] → 16,382 ops/sec [16,059..16,539]	~ overlap (+1.0%)	30,304 ops/sec [30,159..31,121] → 30,698 ops/sec [30,314..30,963]	~ overlap (+1.3%)
class decorator (identity)	23,687 ops/sec [22,177..24,939] → 24,207 ops/sec [23,794..25,293]	~ overlap (+2.2%)	33,664 ops/sec [32,624..34,145] → 33,083 ops/sec [32,214..34,240]	~ overlap (-1.7%)
class decorator (wrapping)	13,617 ops/sec [13,350..15,975] → 13,928 ops/sec [13,518..15,527]	~ overlap (+2.3%)	17,437 ops/sec [16,796..18,899] → 16,874 ops/sec [16,558..17,591]	~ overlap (-3.2%)
identity method decorator	17,398 ops/sec [17,003..17,824] → 17,789 ops/sec [17,539..22,138]	~ overlap (+2.2%)	26,374 ops/sec [26,085..28,673] → 26,650 ops/sec [25,337..27,093]	~ overlap (+1.0%)
wrapping method decorator	14,711 ops/sec [14,109..14,898] → 14,427 ops/sec [14,230..16,689]	~ overlap (-1.9%)	20,023 ops/sec [19,079..21,523] → 19,778 ops/sec [17,262..21,138]	~ overlap (-1.2%)
stacked method decorators (x3)	11,083 ops/sec [10,371..13,909] → 10,646 ops/sec [10,448..10,938]	~ overlap (-3.9%)	13,736 ops/sec [13,643..16,642] → 13,845 ops/sec [13,756..14,088]	~ overlap (+0.8%)
identity field decorator	20,861 ops/sec [20,548..21,339] → 20,339 ops/sec [19,854..20,612]	~ overlap (-2.5%)	24,934 ops/sec [23,662..26,253] → 28,526 ops/sec [24,789..31,731]	~ overlap (+14.4%)
field initializer decorator	18,262 ops/sec [17,035..20,012] → 16,995 ops/sec [16,768..17,148]	~ overlap (-6.9%)	22,438 ops/sec [21,207..25,191] → 22,571 ops/sec [22,115..22,881]	~ overlap (+0.6%)
getter decorator (identity)	16,018 ops/sec [15,520..16,972] → 16,104 ops/sec [15,909..16,914]	~ overlap (+0.5%)	17,117 ops/sec [17,013..17,466] → 17,556 ops/sec [17,431..17,899]	~ overlap (+2.6%)
setter decorator (identity)	13,306 ops/sec [13,073..13,955] → 14,646 ops/sec [13,617..16,185]	~ overlap (+10.1%)	13,532 ops/sec [13,413..13,600] → 14,176 ops/sec [13,739..15,902]	🟢 +4.8%
static method decorator	19,875 ops/sec [19,519..20,044] → 20,146 ops/sec [19,777..20,236]	~ overlap (+1.4%)	30,471 ops/sec [29,078..34,594] → 30,929 ops/sec [29,674..36,792]	~ overlap (+1.5%)
static field decorator	23,646 ops/sec [23,462..26,256] → 22,834 ops/sec [22,458..25,589]	~ overlap (-3.4%)	33,860 ops/sec [32,077..35,723] → 32,085 ops/sec [31,713..39,471]	~ overlap (-5.2%)
private method decorator	13,707 ops/sec [13,460..13,827] → 13,940 ops/sec [13,866..14,035]	🟢 +1.7%	18,742 ops/sec [18,594..18,839] → 18,802 ops/sec [18,221..23,167]	~ overlap (+0.3%)
private field decorator	15,616 ops/sec [15,163..15,721] → 15,385 ops/sec [15,269..15,658]	~ overlap (-1.5%)	16,618 ops/sec [15,931..18,400] → 16,422 ops/sec [16,165..16,558]	~ overlap (-1.2%)
plain auto-accessor (no decorator)	26,347 ops/sec [25,777..31,149] → 25,629 ops/sec [25,224..33,286]	~ overlap (-2.7%)	33,396 ops/sec [32,849..36,876] → 33,985 ops/sec [33,336..35,171]	~ overlap (+1.8%)
auto-accessor with decorator	15,950 ops/sec [15,481..17,860] → 15,757 ops/sec [15,282..15,807]	~ overlap (-1.2%)	18,648 ops/sec [18,239..23,584] → 19,154 ops/sec [18,819..19,559]	~ overlap (+2.7%)
decorator writing metadata	13,336 ops/sec [13,091..13,772] → 13,319 ops/sec [13,052..13,413]	~ overlap (-0.1%)	20,005 ops/sec [18,279..20,998] → 19,250 ops/sec [18,923..20,965]	~ overlap (-3.8%)
static getter read	28,778 ops/sec [28,327..32,949] → 28,846 ops/sec [28,426..29,044]	~ overlap (+0.2%)	60,592 ops/sec [54,197..68,730] → 54,961 ops/sec [51,410..57,378]	~ overlap (-9.3%)
static getter/setter pair	21,522 ops/sec [21,121..21,642] → 21,874 ops/sec [21,714..21,987]	🟢 +1.6%	39,185 ops/sec [37,589..42,754] → 39,226 ops/sec [38,749..40,619]	~ overlap (+0.1%)
inherited static getter	17,913 ops/sec [17,641..20,427] → 18,206 ops/sec [18,078..19,553]	~ overlap (+1.6%)	33,047 ops/sec [32,375..33,330] → 37,262 ops/sec [31,995..39,257]	~ overlap (+12.8%)
inherited static setter	19,714 ops/sec [19,319..20,650] → 19,573 ops/sec [19,281..20,007]	~ overlap (-0.7%)	32,938 ops/sec [30,935..33,632] → 31,620 ops/sec [30,417..32,945]	~ overlap (-4.0%)
inherited static getter with this binding	15,137 ops/sec [15,047..16,920] → 15,048 ops/sec [14,895..15,548]	~ overlap (-0.6%)	27,556 ops/sec [25,991..27,904] → 24,739 ops/sec [24,561..27,802]	~ overlap (-10.2%)

closures.js — Interp: 11 unch. · avg -1.4% · Bytecode: 🟢 1, 10 unch. · avg -1.5%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
closure over single variable	23,508 ops/sec [23,352..28,423] → 23,400 ops/sec [23,238..23,652]	~ overlap (-0.5%)	118,809 ops/sec [116,736..125,152] → 115,721 ops/sec [114,360..116,883]	~ overlap (-2.6%)
closure over multiple variables	28,335 ops/sec [27,942..31,765] → 27,741 ops/sec [27,545..28,296]	~ overlap (-2.1%)	116,820 ops/sec [114,642..125,203] → 116,030 ops/sec [113,936..116,899]	~ overlap (-0.7%)
nested closures	34,176 ops/sec [30,981..38,219] → 30,380 ops/sec [29,909..37,093]	~ overlap (-11.1%)	102,258 ops/sec [101,137..106,124] → 102,418 ops/sec [100,477..117,142]	~ overlap (+0.2%)
function as argument	21,855 ops/sec [21,427..22,580] → 22,034 ops/sec [21,299..22,115]	~ overlap (+0.8%)	114,290 ops/sec [113,452..115,921] → 112,806 ops/sec [111,505..115,979]	~ overlap (-1.3%)
function returning function	27,917 ops/sec [27,619..28,162] → 28,022 ops/sec [27,092..28,112]	~ overlap (+0.4%)	121,107 ops/sec [120,277..125,079] → 119,549 ops/sec [117,247..122,935]	~ overlap (-1.3%)
compose two functions	17,855 ops/sec [17,508..19,445] → 17,740 ops/sec [17,608..18,282]	~ overlap (-0.6%)	73,407 ops/sec [72,501..73,867] → 74,171 ops/sec [73,892..80,480]	🟢 +1.0%
fn.call	35,313 ops/sec [35,172..35,526] → 35,414 ops/sec [35,113..37,542]	~ overlap (+0.3%)	107,043 ops/sec [104,915..107,807] → 106,735 ops/sec [106,000..107,204]	~ overlap (-0.3%)
fn.apply	30,701 ops/sec [30,385..31,149] → 30,541 ops/sec [29,406..30,750]	~ overlap (-0.5%)	88,936 ops/sec [83,326..127,515] → 83,795 ops/sec [83,258..85,787]	~ overlap (-5.8%)
fn.bind	32,041 ops/sec [30,270..32,391] → 31,135 ops/sec [30,724..32,340]	~ overlap (-2.8%)	104,535 ops/sec [101,203..106,132] → 104,000 ops/sec [103,075..108,116]	~ overlap (-0.5%)
recursive sum to 50	2,820 ops/sec [2,739..3,643] → 2,786 ops/sec [2,706..4,379]	~ overlap (-1.2%)	57,701 ops/sec [55,369..59,910] → 55,801 ops/sec [55,430..55,901]	~ overlap (-3.3%)
recursive tree traversal	4,564 ops/sec [4,403..4,653] → 4,637 ops/sec [4,545..4,708]	~ overlap (+1.6%)	16,474 ops/sec [16,107..16,806] → 16,167 ops/sec [15,843..16,344]	~ overlap (-1.9%)

collections.js — Interp: 🟢 2, 10 unch. · avg +3.2% · Bytecode: 🟢 2, 10 unch. · avg +1.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
add 50 elements	2,425 ops/sec [2,411..2,480] → 2,796 ops/sec [2,789..2,857]	🟢 +15.3%	3,182 ops/sec [3,146..3,219] → 3,559 ops/sec [3,468..3,673]	🟢 +11.8%
has lookup (50 elements)	43,530 ops/sec [42,467..43,968] → 44,373 ops/sec [44,219..45,310]	🟢 +1.9%	72,197 ops/sec [71,583..81,294] → 72,460 ops/sec [72,334..74,910]	~ overlap (+0.4%)
delete elements	12,047 ops/sec [11,883..12,509] → 12,503 ops/sec [12,079..13,469]	~ overlap (+3.8%)	16,391 ops/sec [15,681..17,293] → 16,490 ops/sec [16,086..16,701]	~ overlap (+0.6%)
forEach iteration	3,480 ops/sec [3,381..4,047] → 3,411 ops/sec [3,360..4,128]	~ overlap (-2.0%)	6,721 ops/sec [6,501..6,890] → 6,730 ops/sec [6,646..6,923]	~ overlap (+0.1%)
spread to array	10,422 ops/sec [10,019..10,566] → 10,344 ops/sec [9,758..14,029]	~ overlap (-0.7%)	56,915 ops/sec [54,232..60,590] → 58,812 ops/sec [55,074..64,133]	~ overlap (+3.3%)
deduplicate array	9,201 ops/sec [8,989..9,276] → 10,121 ops/sec [9,171..11,271]	~ overlap (+10.0%)	17,124 ops/sec [15,877..18,249] → 16,111 ops/sec [12,228..18,188]	~ overlap (-5.9%)
set 50 entries	1,842 ops/sec [1,751..2,067] → 1,993 ops/sec [1,960..2,184]	~ overlap (+8.2%)	2,526 ops/sec [2,510..2,540] → 2,798 ops/sec [2,696..3,808]	🟢 +10.7%
get lookup (50 entries)	42,296 ops/sec [41,747..44,735] → 42,541 ops/sec [42,359..46,004]	~ overlap (+0.6%)	82,182 ops/sec [77,049..89,060] → 79,189 ops/sec [75,631..90,000]	~ overlap (-3.6%)
has check	55,276 ops/sec [54,766..55,834] → 55,328 ops/sec [54,927..55,774]	~ overlap (+0.1%)	116,153 ops/sec [98,579..122,568] → 107,975 ops/sec [99,690..128,033]	~ overlap (-7.0%)
delete entries	11,509 ops/sec [11,239..11,591] → 11,653 ops/sec [11,193..13,355]	~ overlap (+1.3%)	15,518 ops/sec [15,138..16,639] → 15,070 ops/sec [14,765..15,346]	~ overlap (-2.9%)
forEach iteration	3,425 ops/sec [3,400..3,437] → 3,411 ops/sec [3,366..3,671]	~ overlap (-0.4%)	6,651 ops/sec [6,620..7,793] → 6,812 ops/sec [6,737..7,225]	~ overlap (+2.4%)
keys/values/entries	2,842 ops/sec [2,806..3,020] → 2,854 ops/sec [2,785..3,017]	~ overlap (+0.4%)	9,597 ops/sec [9,450..11,586] → 10,250 ops/sec [9,552..10,630]	~ overlap (+6.8%)

csv.js — Interp: 13 unch. · avg -0.7% · Bytecode: 🔴 1, 12 unch. · avg -0.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple 3-column CSV	32,961 ops/sec [32,559..33,121] → 33,234 ops/sec [32,779..34,627]	~ overlap (+0.8%)	40,828 ops/sec [40,521..42,761] → 41,486 ops/sec [40,880..43,883]	~ overlap (+1.6%)
parse 10-row CSV	9,512 ops/sec [9,018..10,858] → 9,651 ops/sec [9,491..9,774]	~ overlap (+1.5%)	11,158 ops/sec [10,987..12,120] → 11,206 ops/sec [10,864..11,351]	~ overlap (+0.4%)
parse 100-row CSV	1,532 ops/sec [1,484..1,675] → 1,505 ops/sec [1,461..1,518]	~ overlap (-1.8%)	1,666 ops/sec [1,631..1,942] → 1,684 ops/sec [1,646..1,971]	~ overlap (+1.1%)
parse CSV with quoted fields	51,229 ops/sec [49,984..52,641] → 50,565 ops/sec [49,850..51,193]	~ overlap (-1.3%)	72,162 ops/sec [66,256..81,815] → 70,749 ops/sec [65,314..79,229]	~ overlap (-2.0%)
parse without headers (array of arrays)	4,523 ops/sec [4,213..4,911] → 4,346 ops/sec [4,185..4,372]	~ overlap (-3.9%)	4,895 ops/sec [4,847..4,943] → 4,811 ops/sec [4,697..4,843]	🔴 -1.7%
parse with semicolon delimiter	6,942 ops/sec [6,901..7,023] → 6,992 ops/sec [6,970..8,209]	~ overlap (+0.7%)	8,319 ops/sec [8,153..8,799] → 7,998 ops/sec [7,933..8,591]	~ overlap (-3.9%)
stringify array of objects	38,379 ops/sec [37,756..41,544] → 38,933 ops/sec [38,575..39,384]	~ overlap (+1.4%)	56,290 ops/sec [55,824..56,560] → 57,942 ops/sec [56,217..59,546]	~ overlap (+2.9%)
stringify array of arrays	17,218 ops/sec [16,491..17,460] → 16,974 ops/sec [16,919..17,096]	~ overlap (-1.4%)	21,182 ops/sec [20,645..21,576] → 21,243 ops/sec [20,866..27,029]	~ overlap (+0.3%)
stringify with values needing escaping	22,882 ops/sec [21,514..23,887] → 22,132 ops/sec [21,841..22,342]	~ overlap (-3.3%)	29,120 ops/sec [28,700..34,169] → 28,923 ops/sec [28,571..30,865]	~ overlap (-0.7%)
reviver converts numbers	498 ops/sec [497..499] → 495 ops/sec [490..503]	~ overlap (-0.6%)	665 ops/sec [638..742] → 662 ops/sec [651..667]	~ overlap (-0.4%)
reviver filters empty to null	6,368 ops/sec [6,083..6,996] → 6,333 ops/sec [6,271..9,404]	~ overlap (-0.5%)	9,981 ops/sec [9,772..10,518] → 10,109 ops/sec [10,033..10,916]	~ overlap (+1.3%)
parse then stringify	6,039 ops/sec [5,524..6,695] → 5,987 ops/sec [5,810..7,348]	~ overlap (-0.9%)	6,947 ops/sec [6,862..7,530] → 6,889 ops/sec [6,672..9,119]	~ overlap (-0.8%)
stringify then parse	5,798 ops/sec [5,498..6,050] → 5,819 ops/sec [5,534..6,239]	~ overlap (+0.4%)	7,146 ops/sec [6,665..8,264] → 6,939 ops/sec [6,914..6,991]	~ overlap (-2.9%)

destructuring.js — Interp: 🟢 8, 🔴 1, 13 unch. · avg +4.0% · Bytecode: 🟢 6, 🔴 1, 15 unch. · avg +6.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple array destructuring	48,930 ops/sec [47,487..51,217] → 48,645 ops/sec [47,883..50,459]	~ overlap (-0.6%)	79,119 ops/sec [78,762..83,603] → 84,612 ops/sec [80,800..101,936]	~ overlap (+6.9%)
with rest element	41,940 ops/sec [40,769..43,882] → 41,622 ops/sec [41,106..41,878]	~ overlap (-0.8%)	60,179 ops/sec [59,852..60,541] → 61,304 ops/sec [43,742..80,099]	~ overlap (+1.9%)
with defaults	50,585 ops/sec [49,087..53,561] → 50,931 ops/sec [50,361..63,998]	~ overlap (+0.7%)	83,936 ops/sec [82,270..86,173] → 85,298 ops/sec [83,758..85,587]	~ overlap (+1.6%)
skip elements	56,877 ops/sec [56,186..58,102] → 56,557 ops/sec [55,862..56,690]	~ overlap (-0.6%)	86,459 ops/sec [82,698..89,104] → 86,368 ops/sec [85,171..115,128]	~ overlap (-0.1%)
nested array destructuring	25,650 ops/sec [23,457..32,803] → 23,703 ops/sec [23,635..23,903]	~ overlap (-7.6%)	29,788 ops/sec [29,557..29,808] → 30,129 ops/sec [29,158..46,762]	~ overlap (+1.1%)
swap variables	68,329 ops/sec [65,935..69,664] → 68,737 ops/sec [67,027..74,868]	~ overlap (+0.6%)	128,431 ops/sec [127,856..128,736] → 130,530 ops/sec [129,113..132,158]	🟢 +1.6%
simple object destructuring	61,808 ops/sec [59,653..63,142] → 63,047 ops/sec [62,051..65,211]	~ overlap (+2.0%)	116,999 ops/sec [116,198..118,233] → 113,464 ops/sec [112,614..113,899]	🔴 -3.0%
with defaults	65,395 ops/sec [63,968..66,757] → 66,217 ops/sec [64,104..68,034]	~ overlap (+1.3%)	165,742 ops/sec [146,731..187,934] → 156,587 ops/sec [149,286..160,785]	~ overlap (-5.5%)
with renaming	66,558 ops/sec [65,691..70,338] → 67,109 ops/sec [65,938..70,209]	~ overlap (+0.8%)	135,687 ops/sec [131,822..139,719] → 134,329 ops/sec [133,090..148,666]	~ overlap (-1.0%)
nested object destructuring	38,258 ops/sec [37,827..54,745] → 38,130 ops/sec [37,671..40,275]	~ overlap (-0.3%)	67,819 ops/sec [64,014..78,285] → 68,295 ops/sec [67,930..68,613]	~ overlap (+0.7%)
rest properties	33,016 ops/sec [32,883..33,117] → 33,638 ops/sec [33,505..33,834]	🟢 +1.9%	47,400 ops/sec [46,701..64,586] → 49,208 ops/sec [48,841..49,629]	~ overlap (+3.8%)
object parameter	20,582 ops/sec [20,354..20,872] → 20,207 ops/sec [19,383..20,728]	~ overlap (-1.8%)	52,664 ops/sec [52,364..53,237] → 55,165 ops/sec [52,979..55,685]	~ overlap (+4.8%)
array parameter	24,434 ops/sec [24,037..25,172] → 23,965 ops/sec [23,760..23,980]	🔴 -1.9%	49,037 ops/sec [42,890..53,321] → 44,692 ops/sec [43,398..50,000]	~ overlap (-8.9%)
mixed destructuring in map	5,831 ops/sec [5,709..5,880] → 7,096 ops/sec [6,415..7,454]	🟢 +21.7%	10,041 ops/sec [9,876..10,172] → 11,755 ops/sec [11,651..11,850]	🟢 +17.1%
forEach with array destructuring	10,833 ops/sec [10,476..10,870] → 11,747 ops/sec [11,617..11,884]	🟢 +8.4%	15,419 ops/sec [14,572..17,914] → 16,206 ops/sec [15,985..19,761]	~ overlap (+5.1%)
map with array destructuring	11,277 ops/sec [11,110..11,316] → 12,263 ops/sec [11,904..12,995]	🟢 +8.7%	13,321 ops/sec [13,052..14,655] → 14,241 ops/sec [13,590..14,502]	~ overlap (+6.9%)
filter with array destructuring	11,733 ops/sec [11,657..11,838] → 12,153 ops/sec [12,092..12,766]	🟢 +3.6%	14,311 ops/sec [13,557..15,674] → 16,670 ops/sec [14,849..18,492]	~ overlap (+16.5%)
reduce with array destructuring	13,078 ops/sec [13,041..13,103] → 14,421 ops/sec [13,864..14,671]	🟢 +10.3%	15,278 ops/sec [15,095..16,962] → 16,685 ops/sec [16,480..17,507]	~ overlap (+9.2%)
map with object destructuring	13,318 ops/sec [12,799..13,372] → 14,949 ops/sec [14,264..15,720]	🟢 +12.2%	18,922 ops/sec [18,337..20,035] → 22,677 ops/sec [22,287..22,822]	🟢 +19.8%
map with nested destructuring	10,651 ops/sec [10,481..11,923] → 11,827 ops/sec [11,662..12,494]	~ overlap (+11.0%)	19,462 ops/sec [18,306..22,439] → 23,685 ops/sec [23,070..23,815]	🟢 +21.7%
map with rest in destructuring	6,480 ops/sec [6,313..6,712] → 6,761 ops/sec [6,705..6,825]	~ overlap (+4.3%)	6,629 ops/sec [6,512..7,091] → 7,718 ops/sec [7,487..8,744]	🟢 +16.4%
map with defaults in destructuring	7,645 ops/sec [7,620..8,102] → 8,795 ops/sec [8,749..8,823]	🟢 +15.0%	15,101 ops/sec [15,043..15,127] → 18,811 ops/sec [18,616..19,137]	🟢 +24.6%

fibonacci.js — Interp: 🟢 2, 6 unch. · avg +3.5% · Bytecode: 🟢 1, 🔴 1, 6 unch. · avg -2.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
recursive fib(15)	76 ops/sec [76..77] → 78 ops/sec [76..80]	~ overlap (+2.5%)	2,033 ops/sec [1,997..2,165] → 2,003 ops/sec [1,976..2,011]	~ overlap (-1.5%)
recursive fib(20)	7 ops/sec [7..8] → 8 ops/sec [7..8]	~ overlap (+5.2%)	203 ops/sec [184..241] → 177 ops/sec [176..177]	🔴 -12.6%
recursive fib(15) typed	78 ops/sec [77..78] → 79 ops/sec [77..80]	~ overlap (+1.6%)	1,826 ops/sec [1,802..1,960] → 1,793 ops/sec [1,777..1,805]	~ overlap (-1.8%)
recursive fib(20) typed	7 ops/sec [7..8] → 7 ops/sec [7..8]	~ overlap (-0.5%)	165 ops/sec [164..166] → 163 ops/sec [161..166]	~ overlap (-1.3%)
iterative fib(20) via reduce	3,533 ops/sec [3,511..4,405] → 3,868 ops/sec [3,833..3,934]	~ overlap (+9.5%)	5,651 ops/sec [5,540..5,851] → 6,298 ops/sec [6,093..7,964]	🟢 +11.5%
iterator fib(20)	1,872 ops/sec [1,865..1,966] → 1,958 ops/sec [1,919..2,217]	~ overlap (+4.6%)	5,487 ops/sec [5,396..6,074] → 5,375 ops/sec [5,328..5,536]	~ overlap (-2.0%)
iterator fib(20) via Iterator.from + take	1,937 ops/sec [1,874..1,953] → 1,984 ops/sec [1,962..1,996]	🟢 +2.4%	3,441 ops/sec [2,935..3,774] → 3,059 ops/sec [2,935..3,415]	~ overlap (-11.1%)
iterator fib(20) last value via reduce	1,665 ops/sec [1,607..1,678] → 1,709 ops/sec [1,680..1,808]	🟢 +2.6%	2,402 ops/sec [2,288..2,478] → 2,464 ops/sec [2,364..2,925]	~ overlap (+2.6%)

float16array.js — Interp: 🟢 3, 🔴 1, 28 unch. · avg +1.0% · Bytecode: 🟢 1, 31 unch. · avg -0.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
new Float16Array(0)	83,206 ops/sec [83,002..83,461] → 84,001 ops/sec [83,772..84,370]	🟢 +1.0%	116,637 ops/sec [116,549..116,710] → 120,052 ops/sec [116,653..132,481]	~ overlap (+2.9%)
new Float16Array(100)	79,327 ops/sec [78,437..79,933] → 79,888 ops/sec [79,187..79,907]	~ overlap (+0.7%)	113,297 ops/sec [109,700..139,113] → 110,921 ops/sec [108,721..146,562]	~ overlap (-2.1%)
new Float16Array(1000)	71,996 ops/sec [71,083..75,065] → 73,864 ops/sec [73,446..74,171]	~ overlap (+2.6%)	96,481 ops/sec [94,992..149,486] → 95,845 ops/sec [94,503..98,271]	~ overlap (-0.7%)
Float16Array.from([...100])	1,208 ops/sec [1,194..1,213] → 1,172 ops/sec [1,172..1,177]	🔴 -3.0%	1,349 ops/sec [1,311..1,373] → 1,295 ops/sec [1,273..1,401]	~ overlap (-4.0%)
Float16Array.of(1.5, 2.5, 3.5, 4.5, 5.5)	56,731 ops/sec [55,915..57,429] → 57,374 ops/sec [57,080..57,536]	~ overlap (+1.1%)	69,159 ops/sec [66,206..76,690] → 70,758 ops/sec [68,198..74,213]	~ overlap (+2.3%)
new Float16Array(float64Array)	27,812 ops/sec [27,223..28,430] → 27,519 ops/sec [26,941..27,967]	~ overlap (-1.1%)	33,862 ops/sec [33,199..33,959] → 33,316 ops/sec [32,806..33,597]	~ overlap (-1.6%)
sequential write 100 elements	838 ops/sec [828..843] → 834 ops/sec [809..856]	~ overlap (-0.5%)	7,887 ops/sec [7,579..8,069] → 7,542 ops/sec [7,484..7,681]	~ overlap (-4.4%)
sequential read 100 elements	974 ops/sec [972..981] → 977 ops/sec [955..999]	~ overlap (+0.2%)	9,143 ops/sec [9,056..9,435] → 8,879 ops/sec [8,669..9,506]	~ overlap (-2.9%)
write special values (NaN, Inf, -0)	40,810 ops/sec [40,705..45,536] → 44,659 ops/sec [39,119..50,146]	~ overlap (+9.4%)	243,161 ops/sec [237,842..357,369] → 266,542 ops/sec [237,065..390,597]	~ overlap (+9.6%)
Float16Array write	837 ops/sec [818..882] → 860 ops/sec [854..863]	~ overlap (+2.7%)	7,598 ops/sec [7,473..8,811] → 7,569 ops/sec [7,538..7,589]	~ overlap (-0.4%)
Float32Array write	851 ops/sec [841..852] → 861 ops/sec [849..862]	~ overlap (+1.2%)	7,615 ops/sec [7,519..7,942] → 7,506 ops/sec [7,329..7,520]	~ overlap (-1.4%)
Float64Array write	874 ops/sec [857..888] → 860 ops/sec [857..867]	~ overlap (-1.6%)	7,624 ops/sec [7,559..7,635] → 7,677 ops/sec [7,574..8,334]	~ overlap (+0.7%)
Float16Array read	992 ops/sec [981..1,009] → 1,029 ops/sec [997..1,034]	~ overlap (+3.7%)	9,198 ops/sec [9,082..9,344] → 9,111 ops/sec [9,045..9,156]	~ overlap (-0.9%)
Float32Array read	1,025 ops/sec [987..1,028] → 973 ops/sec [949..1,025]	~ overlap (-5.0%)	9,261 ops/sec [9,135..9,494] → 9,161 ops/sec [8,983..9,204]	~ overlap (-1.1%)
Float64Array read	1,003 ops/sec [982..1,029] → 1,039 ops/sec [1,028..1,040]	~ overlap (+3.6%)	9,231 ops/sec [9,041..9,942] → 9,002 ops/sec [8,928..9,570]	~ overlap (-2.5%)
fill(1.5)	8,368 ops/sec [8,092..9,125] → 8,141 ops/sec [8,061..10,427]	~ overlap (-2.7%)	9,122 ops/sec [9,063..9,173] → 9,028 ops/sec [8,968..10,007]	~ overlap (-1.0%)
slice()	40,161 ops/sec [39,659..42,724] → 44,895 ops/sec [44,683..45,120]	🟢 +11.8%	57,747 ops/sec [57,529..58,938] → 58,733 ops/sec [57,231..59,654]	~ overlap (+1.7%)
map(x => x * 2)	1,780 ops/sec [1,631..1,845] → 1,832 ops/sec [1,820..1,848]	~ overlap (+2.9%)	2,069 ops/sec [1,934..2,147] → 2,165 ops/sec [2,151..2,214]	🟢 +4.6%
filter(x => x > 25)	1,781 ops/sec [1,738..1,828] → 1,765 ops/sec [1,759..1,797]	~ overlap (-0.9%)	2,285 ops/sec [2,172..2,314] → 2,289 ops/sec [2,261..2,351]	~ overlap (+0.2%)
reduce (sum)	1,816 ops/sec [1,791..1,836] → 1,839 ops/sec [1,802..1,852]	~ overlap (+1.3%)	1,957 ops/sec [1,825..2,087] → 2,101 ops/sec [2,066..2,675]	~ overlap (+7.3%)
sort()	22,001 ops/sec [21,607..22,091] → 22,197 ops/sec [21,550..30,334]	~ overlap (+0.9%)	24,797 ops/sec [23,605..25,217] → 24,806 ops/sec [24,496..26,818]	~ overlap (+0.0%)
indexOf()	24,808 ops/sec [23,640..26,506] → 24,642 ops/sec [24,533..27,152]	~ overlap (-0.7%)	29,878 ops/sec [28,059..30,209] → 29,989 ops/sec [29,263..31,393]	~ overlap (+0.4%)
reverse()	31,426 ops/sec [31,200..33,095] → 32,592 ops/sec [31,366..32,834]	~ overlap (+3.7%)	37,506 ops/sec [37,068..37,607] → 39,074 ops/sec [37,497..39,315]	~ overlap (+4.2%)
toReversed()	29,279 ops/sec [28,218..32,891] → 28,536 ops/sec [27,870..28,840]	~ overlap (-2.5%)	36,108 ops/sec [32,398..39,049] → 33,835 ops/sec [33,491..34,385]	~ overlap (-6.3%)
toSorted()	13,832 ops/sec [13,550..16,986] → 13,702 ops/sec [13,480..13,860]	~ overlap (-0.9%)	15,143 ops/sec [14,247..17,256] → 15,705 ops/sec [15,437..17,292]	~ overlap (+3.7%)
create view over existing buffer	97,053 ops/sec [94,509..97,166] → 95,942 ops/sec [95,341..98,734]	~ overlap (-1.1%)	148,636 ops/sec [145,539..150,144] → 148,148 ops/sec [144,907..150,649]	~ overlap (-0.3%)
subarray()	49,890 ops/sec [48,174..52,330] → 50,645 ops/sec [50,179..51,784]	~ overlap (+1.5%)	65,976 ops/sec [62,066..69,674] → 62,960 ops/sec [62,408..64,770]	~ overlap (-4.6%)
set() from array	61,018 ops/sec [60,467..61,378] → 62,403 ops/sec [62,043..64,742]	🟢 +2.3%	81,268 ops/sec [79,841..81,972] → 80,191 ops/sec [78,844..86,964]	~ overlap (-1.3%)
for-of loop	1,321 ops/sec [1,286..1,475] → 1,332 ops/sec [1,321..1,408]	~ overlap (+0.8%)	10,387 ops/sec [10,156..10,735] → 10,158 ops/sec [9,935..10,339]	~ overlap (-2.2%)
spread into array	5,386 ops/sec [5,318..5,749] → 5,373 ops/sec [5,339..5,613]	~ overlap (-0.2%)	21,070 ops/sec [20,112..21,611] → 21,352 ops/sec [20,029..25,281]	~ overlap (+1.3%)
f16round(1.337)	132,164 ops/sec [126,664..142,733] → 133,209 ops/sec [131,105..137,172]	~ overlap (+0.8%)	206,069 ops/sec [196,786..219,279] → 198,744 ops/sec [196,249..203,779]	~ overlap (-3.6%)
f16round over 100 values	838 ops/sec [833..852] → 849 ops/sec [831..864]	~ overlap (+1.4%)	2,459 ops/sec [2,422..2,674] → 2,398 ops/sec [2,351..2,484]	~ overlap (-2.5%)

for-in/for-in.js — Interp: 3 unch. · avg +0.8% · Bytecode: 3 unch. · avg +0.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for...in over 50 own keys	2,216 ops/sec [2,130..2,289] → 2,261 ops/sec [2,239..2,309]	~ overlap (+2.0%)	3,780 ops/sec [3,455..4,849] → 3,701 ops/sec [3,550..3,880]	~ overlap (-2.1%)
for...in over an 8-level chain of 50 shared keys	1,569 ops/sec [1,530..1,759] → 1,561 ops/sec [1,534..1,595]	~ overlap (-0.5%)	2,332 ops/sec [2,302..2,461] → 2,389 ops/sec [2,278..2,485]	~ overlap (+2.4%)
for...in over a 16-level chain of 100 shared keys	582 ops/sec [577..592] → 588 ops/sec [572..660]	~ overlap (+0.9%)	794 ops/sec [784..833] → 813 ops/sec [802..822]	~ overlap (+2.3%)

for-of.js — Interp: 🟢 3, 🔴 1, 3 unch. · avg -1.9% · Bytecode: 🟢 1, 6 unch. · avg +0.6%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for...of with 10-element array	11,668 ops/sec [11,255..11,721] → 11,121 ops/sec [10,535..11,675]	~ overlap (-4.7%)	100,588 ops/sec [95,083..107,817] → 94,841 ops/sec [94,240..95,234]	~ overlap (-5.7%)
for...of with 100-element array	1,298 ops/sec [1,292..1,306] → 1,324 ops/sec [1,312..1,350]	🟢 +2.0%	15,408 ops/sec [15,041..16,570] → 15,951 ops/sec [15,255..18,329]	~ overlap (+3.5%)
for...of with string (10 chars)	7,754 ops/sec [7,739..7,782] → 8,117 ops/sec [7,590..8,154]	~ overlap (+4.7%)	17,746 ops/sec [17,614..17,796] → 18,435 ops/sec [18,386..18,544]	🟢 +3.9%
for...of with Set (10 elements)	11,914 ops/sec [11,859..11,981] → 12,209 ops/sec [12,149..12,478]	🟢 +2.5%	141,983 ops/sec [141,248..149,053] → 141,579 ops/sec [140,776..152,333]	~ overlap (-0.3%)
for...of with Map entries (10 entries)	5,950 ops/sec [5,840..5,983] → 6,234 ops/sec [6,037..6,290]	🟢 +4.8%	12,135 ops/sec [11,744..13,440] → 12,554 ops/sec [12,148..13,021]	~ overlap (+3.5%)
for...of with destructuring	6,662 ops/sec [6,566..7,410] → 5,994 ops/sec [5,895..6,953]	~ overlap (-10.0%)	14,532 ops/sec [14,109..14,578] → 14,467 ops/sec [14,298..15,209]	~ overlap (-0.5%)
for-await-of with sync array	7,577 ops/sec [7,495..7,633] → 6,649 ops/sec [6,509..7,341]	🔴 -12.2%	1,919 ops/sec [1,851..2,182] → 1,909 ops/sec [1,883..2,073]	~ overlap (-0.5%)

generators.js — Interp: 🔴 1, 3 unch. · avg -0.6% · Bytecode: 4 unch. · avg +2.3%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
manual next over object generator	558 ops/sec [554..584] → 566 ops/sec [559..613]	~ overlap (+1.3%)	981 ops/sec [972..986] → 990 ops/sec [983..1,062]	~ overlap (+0.9%)
for...of over object generator	822 ops/sec [812..824] → 822 ops/sec [815..837]	~ overlap (+0.0%)	1,500 ops/sec [1,481..1,557] → 1,594 ops/sec [1,501..1,849]	~ overlap (+6.3%)
yield delegation	830 ops/sec [818..869] → 831 ops/sec [817..1,012]	~ overlap (+0.2%)	1,526 ops/sec [1,501..2,344] → 1,545 ops/sec [1,528..1,743]	~ overlap (+1.3%)
class generator method	864 ops/sec [862..869] → 830 ops/sec [813..838]	🔴 -4.0%	1,524 ops/sec [1,506..1,628] → 1,536 ops/sec [1,520..1,828]	~ overlap (+0.8%)

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

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
format decimal	21,065 ops/sec [20,191..23,216] → 20,304 ops/sec [19,136..20,473]	~ overlap (-3.6%)	29,198 ops/sec [28,520..40,818] → 29,270 ops/sec [28,867..30,494]	~ overlap (+0.2%)
format currency	17,245 ops/sec [16,515..18,079] → 16,191 ops/sec [15,685..16,674]	~ overlap (-6.1%)	22,808 ops/sec [22,512..23,733] → 23,143 ops/sec [22,888..25,728]	~ overlap (+1.5%)
format UTC date	7,992 ops/sec [7,795..8,398] → 8,217 ops/sec [7,529..9,615]	~ overlap (+2.8%)	9,544 ops/sec [9,398..11,463] → 9,720 ops/sec [9,567..10,422]	~ overlap (+1.8%)
formatRange UTC dates	2,530 ops/sec [2,516..2,675] → 2,629 ops/sec [2,625..2,657]	~ overlap (+3.9%)	2,907 ops/sec [2,841..3,015] → 2,962 ops/sec [2,842..3,052]	~ overlap (+1.9%)
compare numeric strings	78,969 ops/sec [78,600..79,422] → 81,481 ops/sec [81,107..82,173]	🟢 +3.2%	114,716 ops/sec [112,372..115,228] → 116,832 ops/sec [115,204..121,173]	~ overlap (+1.8%)
sort short string list	14,465 ops/sec [14,442..15,188] → 14,194 ops/sec [13,983..15,115]	~ overlap (-1.9%)	17,130 ops/sec [17,064..17,430] → 17,376 ops/sec [17,194..17,933]	~ overlap (+1.4%)

iterators.js — Interp: 🟢 2, 🔴 2, 38 unch. · avg +0.7% · Bytecode: 🟢 17, 25 unch. · avg +3.7%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Iterator.from({next}).toArray() — 20 elements	2,897 ops/sec [2,885..2,914] → 2,904 ops/sec [2,851..2,957]	~ overlap (+0.3%)	5,326 ops/sec [5,304..5,358] → 5,482 ops/sec [5,436..5,510]	🟢 +2.9%
Iterator.from({next}).toArray() — 50 elements	1,274 ops/sec [1,241..1,407] → 1,237 ops/sec [1,228..1,300]	~ overlap (-2.9%)	2,324 ops/sec [2,280..2,361] → 2,431 ops/sec [2,409..2,452]	🟢 +4.6%
spread pre-wrapped iterator — 20 elements	2,672 ops/sec [2,659..2,699] → 2,611 ops/sec [2,599..2,621]	🔴 -2.3%	5,673 ops/sec [5,641..5,683] → 6,040 ops/sec [6,015..6,376]	🟢 +6.5%
Iterator.from({next}).forEach — 50 elements	895 ops/sec [891..898] → 877 ops/sec [871..882]	🔴 -2.0%	1,600 ops/sec [1,569..1,625] → 1,593 ops/sec [1,580..1,652]	~ overlap (-0.5%)
Iterator.from({next}).reduce — 50 elements	937 ops/sec [926..946] → 944 ops/sec [925..971]	~ overlap (+0.8%)	1,551 ops/sec [1,538..1,566] → 1,575 ops/sec [1,556..1,636]	~ overlap (+1.6%)
wrap array iterator	12,392 ops/sec [12,249..12,440] → 12,341 ops/sec [12,133..12,436]	~ overlap (-0.4%)	13,577 ops/sec [13,162..13,836] → 14,671 ops/sec [14,409..14,804]	🟢 +8.1%
wrap plain {next()} object	1,999 ops/sec [1,941..2,018] → 2,031 ops/sec [1,993..2,192]	~ overlap (+1.6%)	3,635 ops/sec [3,576..3,663] → 3,808 ops/sec [3,790..3,831]	🟢 +4.8%
map + toArray (50 elements)	681 ops/sec [668..694] → 665 ops/sec [660..680]	~ overlap (-2.3%)	961 ops/sec [934..1,062] → 1,003 ops/sec [980..1,072]	~ overlap (+4.4%)
filter + toArray (50 elements)	730 ops/sec [712..756] → 710 ops/sec [702..882]	~ overlap (-2.8%)	1,110 ops/sec [1,060..1,145] → 1,103 ops/sec [1,095..1,139]	~ overlap (-0.7%)
take(10) + toArray (50 element source)	3,675 ops/sec [3,655..3,829] → 3,723 ops/sec [3,699..3,746]	~ overlap (+1.3%)	5,250 ops/sec [5,208..5,296] → 5,466 ops/sec [5,327..5,712]	🟢 +4.1%
drop(40) + toArray (50 element source)	999 ops/sec [964..1,014] → 1,059 ops/sec [997..1,112]	~ overlap (+6.0%)	1,584 ops/sec [1,563..1,609] → 1,651 ops/sec [1,597..1,721]	~ overlap (+4.3%)
chained map + filter + take (100 element source)	1,074 ops/sec [1,041..1,121] → 1,082 ops/sec [1,070..1,101]	~ overlap (+0.8%)	1,441 ops/sec [1,379..1,543] → 1,434 ops/sec [1,414..1,531]	~ overlap (-0.5%)
some + every (50 elements)	501 ops/sec [498..568] → 535 ops/sec [524..660]	~ overlap (+6.9%)	900 ops/sec [895..903] → 898 ops/sec [883..919]	~ overlap (-0.2%)
find (50 elements)	1,162 ops/sec [1,159..1,194] → 1,187 ops/sec [1,153..1,196]	~ overlap (+2.2%)	1,923 ops/sec [1,906..1,972] → 1,962 ops/sec [1,946..1,978]	~ overlap (+2.0%)
concat 2 arrays (10 + 10 elements)	4,994 ops/sec [4,918..5,226] → 5,232 ops/sec [4,892..5,724]	~ overlap (+4.8%)	5,234 ops/sec [5,115..5,356] → 5,569 ops/sec [5,358..6,415]	🟢 +6.4%
concat 5 arrays (10 elements each)	2,170 ops/sec [2,078..2,536] → 2,153 ops/sec [2,124..2,224]	~ overlap (-0.7%)	2,293 ops/sec [2,230..2,824] → 2,354 ops/sec [2,290..2,430]	~ overlap (+2.7%)
concat 2 arrays (20 + 20 elements)	2,826 ops/sec [2,647..2,846] → 2,768 ops/sec [2,725..2,884]	~ overlap (-2.1%)	3,058 ops/sec [2,950..3,239] → 3,004 ops/sec [2,998..3,043]	~ overlap (-1.8%)
concat + filter + toArray (20 + 20 elements)	1,231 ops/sec [1,189..1,312] → 1,349 ops/sec [1,203..1,746]	~ overlap (+9.6%)	1,383 ops/sec [1,375..1,395] → 1,477 ops/sec [1,406..1,586]	🟢 +6.7%
concat + map + take (20 + 20 elements, take 10)	2,919 ops/sec [2,888..3,000] → 2,900 ops/sec [2,833..2,933]	~ overlap (-0.6%)	3,353 ops/sec [3,184..3,380] → 3,325 ops/sec [3,266..3,349]	~ overlap (-0.8%)
concat Sets (15 + 15 elements)	3,734 ops/sec [3,654..3,742] → 3,811 ops/sec [3,765..4,207]	🟢 +2.1%	4,067 ops/sec [3,888..5,132] → 4,056 ops/sec [4,046..4,085]	~ overlap (-0.3%)
concat boxed strings (13 + 13 characters)	3,757 ops/sec [3,718..4,044] → 3,797 ops/sec [3,754..3,833]	~ overlap (+1.1%)	4,606 ops/sec [3,929..5,075] → 4,114 ops/sec [4,048..4,126]	~ overlap (-10.7%)
zip 2 arrays (10 + 10 elements)	8,937 ops/sec [8,823..8,974] → 9,002 ops/sec [8,764..10,676]	~ overlap (+0.7%)	9,897 ops/sec [9,501..11,760] → 9,888 ops/sec [9,807..9,979]	~ overlap (-0.1%)
zip 3 arrays (10 elements each)	8,359 ops/sec [8,176..8,470] → 8,726 ops/sec [8,261..11,098]	~ overlap (+4.4%)	8,996 ops/sec [8,904..9,075] → 9,355 ops/sec [9,188..9,387]	🟢 +4.0%
zip 2 arrays (20 + 20 elements)	5,386 ops/sec [5,233..5,538] → 5,310 ops/sec [5,154..5,412]	~ overlap (-1.4%)	5,656 ops/sec [5,597..5,755] → 6,399 ops/sec [5,819..6,658]	🟢 +13.1%
zip 2 arrays (50 + 50 elements)	2,483 ops/sec [2,339..2,710] → 2,734 ops/sec [2,421..2,900]	~ overlap (+10.1%)	2,611 ops/sec [2,557..2,615] → 3,149 ops/sec [2,578..4,070]	~ overlap (+20.6%)
zip shortest mode (20 + 10 elements)	8,876 ops/sec [8,365..9,652] → 8,975 ops/sec [8,631..13,695]	~ overlap (+1.1%)	10,178 ops/sec [9,412..10,903] → 9,823 ops/sec [9,739..9,865]	~ overlap (-3.5%)
zip longest mode (10 + 20 elements)	5,245 ops/sec [5,097..5,850] → 5,384 ops/sec [5,138..6,577]	~ overlap (+2.6%)	5,500 ops/sec [5,447..5,503] → 5,782 ops/sec [5,500..6,018]	~ overlap (+5.1%)
zip strict mode (20 + 20 elements)	5,268 ops/sec [5,181..5,406] → 5,279 ops/sec [5,229..5,301]	~ overlap (+0.2%)	5,333 ops/sec [5,291..5,343] → 5,634 ops/sec [5,562..7,772]	🟢 +5.6%
zip + map + toArray (20 + 20 elements)	1,813 ops/sec [1,738..1,868] → 1,749 ops/sec [1,725..1,982]	~ overlap (-3.5%)	1,804 ops/sec [1,773..1,907] → 1,896 ops/sec [1,887..1,944]	~ overlap (+5.1%)
zip + filter + toArray (20 + 20 elements)	1,914 ops/sec [1,867..1,959] → 1,898 ops/sec [1,859..2,011]	~ overlap (-0.8%)	2,014 ops/sec [1,957..2,051] → 2,098 ops/sec [2,049..2,164]	~ overlap (+4.2%)
zip Sets (15 + 15 elements)	7,213 ops/sec [7,111..7,329] → 7,489 ops/sec [7,462..7,518]	🟢 +3.8%	7,707 ops/sec [7,578..7,992] → 8,066 ops/sec [7,784..8,723]	~ overlap (+4.7%)
zipKeyed 2 keys (10 elements each)	8,928 ops/sec [8,525..10,737] → 8,786 ops/sec [8,364..9,133]	~ overlap (-1.6%)	9,267 ops/sec [8,871..9,350] → 9,696 ops/sec [9,508..12,441]	🟢 +4.6%
zipKeyed 3 keys (20 elements each)	4,440 ops/sec [4,368..4,613] → 4,605 ops/sec [4,391..4,725]	~ overlap (+3.7%)	4,778 ops/sec [4,723..5,299] → 4,938 ops/sec [4,873..5,240]	~ overlap (+3.4%)
zipKeyed longest mode (10 + 20 elements)	5,114 ops/sec [4,785..5,439] → 4,992 ops/sec [4,916..6,860]	~ overlap (-2.4%)	5,245 ops/sec [5,185..5,309] → 5,593 ops/sec [5,437..5,960]	🟢 +6.6%
zipKeyed strict mode (20 + 20 elements)	5,283 ops/sec [5,188..5,310] → 5,265 ops/sec [4,929..5,688]	~ overlap (-0.3%)	5,265 ops/sec [5,158..5,731] → 5,454 ops/sec [5,308..6,981]	~ overlap (+3.6%)
zipKeyed + filter + map (20 elements)	1,615 ops/sec [1,591..1,677] → 1,613 ops/sec [1,577..1,766]	~ overlap (-0.1%)	1,942 ops/sec [1,935..1,954] → 2,085 ops/sec [1,982..2,225]	🟢 +7.3%
array.values().map().filter().toArray()	684 ops/sec [643..726] → 657 ops/sec [651..690]	~ overlap (-4.0%)	736 ops/sec [731..819] → 764 ops/sec [742..805]	~ overlap (+3.9%)
array.values().take(5).toArray()	11,564 ops/sec [11,046..11,834] → 11,163 ops/sec [10,300..12,217]	~ overlap (-3.5%)	11,608 ops/sec [11,516..11,700] → 12,133 ops/sec [11,895..12,270]	🟢 +4.5%
array.values().drop(45).toArray()	2,407 ops/sec [2,350..2,996] → 2,405 ops/sec [2,343..2,423]	~ overlap (-0.1%)	2,375 ops/sec [2,369..2,400] → 2,566 ops/sec [2,452..2,948]	🟢 +8.0%
map.entries() chained helpers	939 ops/sec [901..1,022] → 921 ops/sec [888..1,059]	~ overlap (-1.9%)	971 ops/sec [952..1,026] → 1,032 ops/sec [1,000..1,418]	~ overlap (+6.4%)
set.values() chained helpers	1,612 ops/sec [1,599..1,636] → 1,639 ops/sec [1,603..1,670]	~ overlap (+1.7%)	1,837 ops/sec [1,802..1,840] → 1,941 ops/sec [1,869..2,308]	🟢 +5.7%
string iterator map + toArray	1,622 ops/sec [1,585..1,880] → 1,613 ops/sec [1,570..1,664]	~ overlap (-0.6%)	1,747 ops/sec [1,687..1,922] → 1,721 ops/sec [1,700..1,749]	~ overlap (-1.5%)

json.js — Interp: 🟢 1, 22 unch. · avg +0.0% · Bytecode: 23 unch. · avg -0.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple object	40,815 ops/sec [40,428..42,905] → 43,003 ops/sec [42,246..43,464]	~ overlap (+5.4%)	54,598 ops/sec [53,486..61,572] → 54,601 ops/sec [50,642..55,601]	~ overlap (+0.0%)
parse nested object	26,514 ops/sec [26,283..27,444] → 27,678 ops/sec [26,893..28,120]	~ overlap (+4.4%)	33,028 ops/sec [32,683..33,200] → 33,949 ops/sec [33,179..34,118]	~ overlap (+2.8%)
parse array of objects	15,569 ops/sec [15,426..15,700] → 15,884 ops/sec [15,731..15,938]	🟢 +2.0%	18,549 ops/sec [17,566..19,155] → 19,193 ops/sec [18,835..19,330]	~ overlap (+3.5%)
parse large flat object	17,071 ops/sec [16,924..17,200] → 17,422 ops/sec [16,928..17,519]	~ overlap (+2.1%)	20,239 ops/sec [19,117..22,272] → 20,180 ops/sec [20,004..20,447]	~ overlap (-0.3%)
parse mixed types	13,901 ops/sec [13,683..14,052] → 13,783 ops/sec [13,683..13,883]	~ overlap (-0.8%)	16,907 ops/sec [16,346..20,545] → 16,799 ops/sec [16,023..17,412]	~ overlap (-0.6%)
stringify simple object	42,721 ops/sec [42,398..43,187] → 42,429 ops/sec [41,291..48,679]	~ overlap (-0.7%)	53,100 ops/sec [47,842..55,896] → 52,259 ops/sec [51,205..52,648]	~ overlap (-1.6%)
stringify nested object	25,882 ops/sec [25,801..25,962] → 24,668 ops/sec [24,295..31,787]	~ overlap (-4.7%)	29,743 ops/sec [28,518..33,928] → 29,197 ops/sec [28,973..30,927]	~ overlap (-1.8%)
stringify array of objects	10,692 ops/sec [10,437..11,445] → 10,611 ops/sec [10,545..10,881]	~ overlap (-0.8%)	12,963 ops/sec [12,823..14,265] → 12,995 ops/sec [12,125..13,725]	~ overlap (+0.2%)
stringify mixed types	20,945 ops/sec [20,585..21,316] → 20,857 ops/sec [20,568..21,428]	~ overlap (-0.4%)	24,748 ops/sec [24,441..25,131] → 24,967 ops/sec [24,780..26,639]	~ overlap (+0.9%)
reviver doubles numbers	7,554 ops/sec [7,473..7,888] → 7,871 ops/sec [7,624..8,710]	~ overlap (+4.2%)	11,711 ops/sec [11,306..11,887] → 11,382 ops/sec [11,238..11,473]	~ overlap (-2.8%)
reviver filters properties	7,755 ops/sec [7,672..8,197] → 7,681 ops/sec [7,590..7,825]	~ overlap (-1.0%)	11,240 ops/sec [10,506..12,370] → 10,557 ops/sec [10,397..10,667]	~ overlap (-6.1%)
reviver on nested object	9,037 ops/sec [9,003..9,301] → 9,295 ops/sec [8,837..9,390]	~ overlap (+2.8%)	12,572 ops/sec [12,243..12,714] → 12,558 ops/sec [12,427..12,669]	~ overlap (-0.1%)
reviver on array	4,822 ops/sec [4,748..5,237] → 4,780 ops/sec [4,728..4,794]	~ overlap (-0.9%)	7,473 ops/sec [7,288..7,582] → 7,471 ops/sec [7,313..8,360]	~ overlap (-0.0%)
replacer function doubles numbers	9,249 ops/sec [8,696..9,696] → 8,958 ops/sec [8,714..9,123]	~ overlap (-3.1%)	14,353 ops/sec [14,235..14,788] → 14,527 ops/sec [14,383..14,713]	~ overlap (+1.2%)
replacer function excludes properties	12,070 ops/sec [11,763..12,956] → 12,157 ops/sec [11,597..12,329]	~ overlap (+0.7%)	20,109 ops/sec [19,749..21,098] → 20,071 ops/sec [19,927..20,167]	~ overlap (-0.2%)
array replacer (allowlist)	32,395 ops/sec [31,710..34,375] → 32,811 ops/sec [32,538..33,060]	~ overlap (+1.3%)	41,695 ops/sec [39,900..44,265] → 41,258 ops/sec [38,744..42,027]	~ overlap (-1.0%)
stringify with 2-space indent	24,987 ops/sec [24,600..26,116] → 24,886 ops/sec [24,585..24,962]	~ overlap (-0.4%)	30,678 ops/sec [29,244..32,549] → 29,926 ops/sec [29,312..30,612]	~ overlap (-2.5%)
stringify with tab indent	24,672 ops/sec [24,024..25,764] → 24,463 ops/sec [24,250..25,020]	~ overlap (-0.8%)	31,295 ops/sec [30,745..31,627] → 29,824 ops/sec [29,384..31,233]	~ overlap (-4.7%)
stringify deeply nested object with 2-space indent	3,898 ops/sec [3,767..4,606] → 3,873 ops/sec [3,710..4,054]	~ overlap (-0.6%)	4,416 ops/sec [4,395..4,663] → 4,422 ops/sec [4,345..4,538]	~ overlap (+0.1%)
stringify deeply nested array with 2-space indent	5,416 ops/sec [5,242..6,917] → 5,232 ops/sec [5,179..5,392]	~ overlap (-3.4%)	6,002 ops/sec [5,952..6,548] → 6,247 ops/sec [6,196..6,662]	~ overlap (+4.1%)
stringify very deeply nested object with 2-space indent	657 ops/sec [631..663] → 663 ops/sec [640..676]	~ overlap (+0.9%)	714 ops/sec [684..717] → 711 ops/sec [685..738]	~ overlap (-0.5%)
parse then stringify	14,027 ops/sec [13,090..14,380] → 13,279 ops/sec [13,015..13,745]	~ overlap (-5.3%)	16,968 ops/sec [16,478..20,331] → 16,914 ops/sec [16,847..17,555]	~ overlap (-0.3%)
stringify then parse	8,165 ops/sec [8,048..8,428] → 8,107 ops/sec [7,957..8,589]	~ overlap (-0.7%)	9,871 ops/sec [9,755..10,511] → 9,969 ops/sec [9,917..11,032]	~ overlap (+1.0%)

jsx.jsx — Interp: 21 unch. · avg -0.5% · Bytecode: 🟢 1, 🔴 1, 19 unch. · avg -0.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple element	66,074 ops/sec [65,762..66,389] → 63,412 ops/sec [62,967..69,273]	~ overlap (-4.0%)	116,548 ops/sec [111,412..134,618] → 116,792 ops/sec [113,471..130,233]	~ overlap (+0.2%)
self-closing element	65,802 ops/sec [65,311..67,636] → 66,482 ops/sec [66,013..74,980]	~ overlap (+1.0%)	120,210 ops/sec [117,711..129,389] → 120,820 ops/sec [119,114..124,374]	~ overlap (+0.5%)
element with string attribute	60,848 ops/sec [55,422..66,471] → 57,042 ops/sec [56,305..57,403]	~ overlap (-6.3%)	93,640 ops/sec [91,543..94,426] → 90,811 ops/sec [89,412..117,298]	~ overlap (-3.0%)
element with multiple attributes	47,376 ops/sec [46,732..48,065] → 47,961 ops/sec [47,460..51,939]	~ overlap (+1.2%)	73,375 ops/sec [72,086..74,192] → 72,161 ops/sec [71,092..79,430]	~ overlap (-1.7%)
element with expression attribute	50,352 ops/sec [47,489..57,988] → 50,116 ops/sec [49,596..50,946]	~ overlap (-0.5%)	90,275 ops/sec [88,657..115,297] → 90,740 ops/sec [88,871..92,784]	~ overlap (+0.5%)
text child	63,898 ops/sec [62,137..65,446] → 63,515 ops/sec [61,617..67,511]	~ overlap (-0.6%)	118,842 ops/sec [116,678..121,276] → 119,220 ops/sec [117,289..177,973]	~ overlap (+0.3%)
expression child	57,722 ops/sec [55,897..67,379] → 57,726 ops/sec [57,242..57,806]	~ overlap (+0.0%)	115,327 ops/sec [112,829..116,177] → 118,328 ops/sec [115,523..141,406]	~ overlap (+2.6%)
mixed text and expression	54,476 ops/sec [53,023..60,465] → 55,595 ops/sec [54,675..58,050]	~ overlap (+2.1%)	117,201 ops/sec [109,236..119,635] → 118,203 ops/sec [109,689..122,593]	~ overlap (+0.9%)
nested elements (3 levels)	26,162 ops/sec [25,966..26,849] → 26,727 ops/sec [25,987..30,620]	~ overlap (+2.2%)	46,607 ops/sec [45,714..48,495] → 46,538 ops/sec [46,019..47,638]	~ overlap (-0.1%)
sibling children	19,644 ops/sec [19,112..19,856] → 22,716 ops/sec [19,342..24,742]	~ overlap (+15.6%)	35,928 ops/sec [34,436..42,943] → 35,250 ops/sec [34,661..35,844]	~ overlap (-1.9%)
component element	51,033 ops/sec [44,786..62,176] → 48,341 ops/sec [45,365..54,793]	~ overlap (-5.3%)	82,857 ops/sec [79,541..84,283] → 81,026 ops/sec [79,900..97,195]	~ overlap (-2.2%)
component with children	29,611 ops/sec [28,791..31,647] → 29,079 ops/sec [28,598..29,299]	~ overlap (-1.8%)	56,158 ops/sec [51,255..58,189] → 51,491 ops/sec [50,512..52,082]	~ overlap (-8.3%)
dotted component	39,831 ops/sec [39,399..40,619] → 39,262 ops/sec [39,152..39,781]	~ overlap (-1.4%)	64,387 ops/sec [63,154..66,928] → 63,968 ops/sec [63,563..64,668]	~ overlap (-0.7%)
empty fragment	71,474 ops/sec [70,658..80,897] → 72,763 ops/sec [67,292..78,287]	~ overlap (+1.8%)	127,384 ops/sec [123,580..133,877] → 122,117 ops/sec [120,386..122,982]	🔴 -4.1%
fragment with children	20,164 ops/sec [19,545..24,728] → 20,405 ops/sec [20,168..20,479]	~ overlap (+1.2%)	34,722 ops/sec [34,031..35,324] → 35,757 ops/sec [35,109..35,967]	~ overlap (+3.0%)
spread attributes	31,248 ops/sec [30,134..32,887] → 31,401 ops/sec [31,203..31,617]	~ overlap (+0.5%)	45,172 ops/sec [44,294..45,745] → 45,536 ops/sec [44,332..45,761]	~ overlap (+0.8%)
spread with overrides	30,427 ops/sec [26,302..31,569] → 27,080 ops/sec [26,525..34,007]	~ overlap (-11.0%)	37,685 ops/sec [36,863..38,599] → 38,199 ops/sec [37,369..43,694]	~ overlap (+1.4%)
shorthand props	46,901 ops/sec [44,437..62,496] → 45,812 ops/sec [43,362..51,811]	~ overlap (-2.3%)	83,082 ops/sec [82,352..83,527] → 84,315 ops/sec [80,200..88,220]	~ overlap (+1.5%)
nav bar structure	9,811 ops/sec [9,385..10,888] → 9,849 ops/sec [9,400..11,838]	~ overlap (+0.4%)	15,644 ops/sec [15,536..15,687] → 16,209 ops/sec [16,110..22,777]	🟢 +3.6%
card component tree	11,489 ops/sec [10,959..13,615] → 11,246 ops/sec [10,912..11,762]	~ overlap (-2.1%)	17,573 ops/sec [17,451..17,638] → 18,064 ops/sec [17,264..21,408]	~ overlap (+2.8%)
10 list items via Array.from	4,773 ops/sec [4,645..4,918] → 4,682 ops/sec [4,658..4,705]	~ overlap (-1.9%)	6,178 ops/sec [6,120..6,335] → 6,153 ops/sec [6,105..6,256]	~ overlap (-0.4%)

modules.js — Interp: 🔴 1, 8 unch. · avg -0.6% · Bytecode: 🟢 1, 8 unch. · avg +4.8%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
call imported function	100,876 ops/sec [98,665..117,971] → 106,537 ops/sec [102,417..113,079]	~ overlap (+5.6%)	395,928 ops/sec [383,219..439,750] → 388,985 ops/sec [388,017..442,981]	~ overlap (-1.8%)
call two imported functions	57,104 ops/sec [54,654..57,633] → 55,948 ops/sec [55,525..57,220]	~ overlap (-2.0%)	287,479 ops/sec [255,392..309,707] → 287,104 ops/sec [255,230..310,433]	~ overlap (-0.1%)
read imported constant	258,567 ops/sec [254,787..267,718] → 253,823 ops/sec [249,379..331,347]	~ overlap (-1.8%)	507,946 ops/sec [487,447..555,125] → 584,677 ops/sec [504,295..678,709]	~ overlap (+15.1%)
read imported string	265,085 ops/sec [248,848..312,441] → 260,667 ops/sec [252,713..263,086]	~ overlap (-1.7%)	559,195 ops/sec [523,435..685,436] → 609,546 ops/sec [533,707..640,220]	~ overlap (+9.0%)
read JSON string property	257,821 ops/sec [257,504..258,844] → 273,093 ops/sec [249,574..283,003]	~ overlap (+5.9%)	545,853 ops/sec [525,835..807,875] → 550,332 ops/sec [531,082..624,492]	~ overlap (+0.8%)
read JSON number property	257,755 ops/sec [254,232..267,090] → 249,127 ops/sec [240,428..268,501]	~ overlap (-3.3%)	527,062 ops/sec [524,169..644,505] → 529,361 ops/sec [518,954..581,996]	~ overlap (+0.4%)
read JSON boolean property	262,028 ops/sec [256,186..267,387] → 264,934 ops/sec [247,359..348,374]	~ overlap (+1.1%)	547,757 ops/sec [519,829..614,033] → 556,372 ops/sec [531,100..624,069]	~ overlap (+1.6%)
read JSON array property	256,698 ops/sec [247,757..260,313] → 252,728 ops/sec [247,302..267,949]	~ overlap (-1.5%)	511,606 ops/sec [507,977..562,590] → 583,331 ops/sec [537,551..655,424]	~ overlap (+14.0%)
read multiple JSON properties	132,790 ops/sec [130,496..159,174] → 123,090 ops/sec [122,573..125,915]	🔴 -7.3%	360,867 ops/sec [358,883..368,534] → 375,455 ops/sec [374,612..376,187]	🟢 +4.0%

numbers.js — Interp: 🔴 1, 11 unch. · avg -0.7% · Bytecode: 12 unch. · avg +2.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
integer arithmetic	60,215 ops/sec [59,639..71,178] → 62,185 ops/sec [61,136..65,763]	~ overlap (+3.3%)	525,832 ops/sec [524,790..572,589] → 513,517 ops/sec [510,783..525,580]	~ overlap (-2.3%)
floating point arithmetic	76,182 ops/sec [75,938..76,558] → 72,450 ops/sec [71,570..73,474]	🔴 -4.9%	386,328 ops/sec [362,639..401,112] → 407,511 ops/sec [372,040..421,687]	~ overlap (+5.5%)
number coercion	15,379 ops/sec [14,839..16,040] → 15,145 ops/sec [14,682..15,428]	~ overlap (-1.5%)	22,648 ops/sec [21,891..22,684] → 22,159 ops/sec [21,868..28,590]	~ overlap (-2.2%)
toFixed	25,795 ops/sec [25,187..25,901] → 25,561 ops/sec [25,263..26,236]	~ overlap (-0.9%)	33,192 ops/sec [31,995..34,105] → 33,996 ops/sec [33,141..34,257]	~ overlap (+2.4%)
toString	39,491 ops/sec [38,616..51,921] → 40,417 ops/sec [38,525..41,826]	~ overlap (+2.3%)	54,698 ops/sec [53,073..73,235] → 54,121 ops/sec [53,692..56,843]	~ overlap (-1.1%)
toString non-integer (shortest round-trip)	8,429 ops/sec [8,164..12,186] → 8,399 ops/sec [8,309..8,706]	~ overlap (-0.4%)	15,028 ops/sec [14,694..19,655] → 15,229 ops/sec [14,019..15,550]	~ overlap (+1.3%)
valueOf	53,548 ops/sec [52,920..53,827] → 53,001 ops/sec [52,188..55,497]	~ overlap (-1.0%)	73,485 ops/sec [70,621..79,885] → 77,399 ops/sec [73,421..87,153]	~ overlap (+5.3%)
toPrecision	24,622 ops/sec [23,764..24,909] → 24,868 ops/sec [24,733..25,755]	~ overlap (+1.0%)	30,438 ops/sec [29,966..34,841] → 32,004 ops/sec [30,450..36,708]	~ overlap (+5.1%)
Number.isNaN	59,009 ops/sec [51,755..66,527] → 55,254 ops/sec [54,599..55,833]	~ overlap (-6.4%)	85,216 ops/sec [80,383..124,754] → 83,730 ops/sec [80,093..90,445]	~ overlap (-1.7%)
Number.isFinite	54,113 ops/sec [52,031..72,061] → 55,022 ops/sec [54,087..55,516]	~ overlap (+1.7%)	75,453 ops/sec [73,769..77,349] → 77,188 ops/sec [76,175..87,264]	~ overlap (+2.3%)
Number.isInteger	55,949 ops/sec [52,356..58,489] → 56,288 ops/sec [56,029..57,123]	~ overlap (+0.6%)	75,399 ops/sec [75,186..77,731] → 79,905 ops/sec [77,417..92,842]	~ overlap (+6.0%)
Number.parseInt and parseFloat	21,454 ops/sec [20,265..23,529] → 21,039 ops/sec [20,423..21,538]	~ overlap (-1.9%)	26,124 ops/sec [25,227..27,599] → 26,998 ops/sec [26,596..30,945]	~ overlap (+3.3%)

objects.js — Interp: 8 unch. · avg -3.1% · Bytecode: 8 unch. · avg +1.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
create simple object	133,703 ops/sec [128,005..167,028] → 128,612 ops/sec [128,074..130,432]	~ overlap (-3.8%)	152,127 ops/sec [150,745..160,183] → 155,359 ops/sec [149,580..192,309]	~ overlap (+2.1%)
create nested object	73,090 ops/sec [72,383..77,584] → 76,507 ops/sec [73,357..85,735]	~ overlap (+4.7%)	76,310 ops/sec [73,525..81,935] → 76,847 ops/sec [72,349..77,684]	~ overlap (+0.7%)
create 50 objects via Array.from	2,460 ops/sec [2,431..2,577] → 2,499 ops/sec [2,429..2,938]	~ overlap (+1.6%)	2,486 ops/sec [2,465..3,137] → 2,545 ops/sec [2,452..3,159]	~ overlap (+2.4%)
property read	106,643 ops/sec [101,600..123,953] → 100,823 ops/sec [99,595..105,111]	~ overlap (-5.5%)	409,591 ops/sec [400,048..442,116] → 396,507 ops/sec [391,677..442,682]	~ overlap (-3.2%)
Object.keys	60,084 ops/sec [55,150..65,896] → 55,409 ops/sec [53,335..55,907]	~ overlap (-7.8%)	70,558 ops/sec [69,617..87,439] → 69,878 ops/sec [68,634..73,376]	~ overlap (-1.0%)
Object.keys over 2000 descending-inserted index keys	456 ops/sec [408..467] → 408 ops/sec [394..420]	~ overlap (-10.6%)	453 ops/sec [452..456] → 451 ops/sec [424..496]	~ overlap (-0.4%)
Object.entries	31,006 ops/sec [29,061..34,728] → 30,426 ops/sec [29,218..38,316]	~ overlap (-1.9%)	33,770 ops/sec [32,865..37,074] → 36,586 ops/sec [33,591..37,786]	~ overlap (+8.3%)
spread operator	39,781 ops/sec [37,897..41,849] → 39,016 ops/sec [38,128..40,212]	~ overlap (-1.9%)	49,943 ops/sec [49,275..50,489] → 49,745 ops/sec [48,121..59,806]	~ overlap (-0.4%)

promises.js — Interp: 🟢 1, 11 unch. · avg +3.5% · Bytecode: 🔴 1, 11 unch. · avg -0.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Promise.resolve(value)	55,595 ops/sec [54,205..56,266] → 54,202 ops/sec [53,591..70,374]	~ overlap (-2.5%)	65,759 ops/sec [63,832..90,906] → 64,393 ops/sec [61,945..65,404]	~ overlap (-2.1%)
new Promise(resolve => resolve(value))	38,043 ops/sec [37,902..40,070] → 40,386 ops/sec [39,769..45,457]	~ overlap (+6.2%)	48,790 ops/sec [47,675..66,396] → 48,817 ops/sec [48,480..52,663]	~ overlap (+0.1%)
Promise.reject(reason)	57,907 ops/sec [54,218..74,195] → 55,351 ops/sec [53,182..57,716]	~ overlap (-4.4%)	66,535 ops/sec [64,879..66,699] → 69,033 ops/sec [65,684..70,238]	~ overlap (+3.8%)
resolve + then (1 handler)	18,367 ops/sec [17,941..22,011] → 19,216 ops/sec [18,548..21,183]	~ overlap (+4.6%)	21,958 ops/sec [21,604..22,401] → 22,353 ops/sec [20,881..24,831]	~ overlap (+1.8%)
resolve + then chain (3 deep)	7,833 ops/sec [7,806..7,968] → 7,892 ops/sec [7,597..8,804]	~ overlap (+0.8%)	9,222 ops/sec [9,179..9,260] → 9,409 ops/sec [9,118..9,429]	~ overlap (+2.0%)
resolve + then chain (10 deep)	2,654 ops/sec [2,646..2,936] → 2,755 ops/sec [2,568..3,027]	~ overlap (+3.8%)	3,510 ops/sec [3,209..3,670] → 3,199 ops/sec [3,003..3,228]	~ overlap (-8.9%)
reject + catch + then	11,139 ops/sec [11,103..11,165] → 12,612 ops/sec [10,732..13,322]	~ overlap (+13.2%)	12,758 ops/sec [12,499..16,468] → 12,850 ops/sec [12,396..13,157]	~ overlap (+0.7%)
resolve + finally + then	5,288 ops/sec [5,243..6,162] → 5,293 ops/sec [5,197..5,843]	~ overlap (+0.1%)	5,818 ops/sec [5,730..5,873] → 5,937 ops/sec [5,857..7,030]	~ overlap (+2.0%)
Promise.all (5 resolved)	3,678 ops/sec [3,472..4,148] → 3,714 ops/sec [3,394..4,167]	~ overlap (+1.0%)	4,055 ops/sec [4,038..4,072] → 3,926 ops/sec [3,862..3,951]	🔴 -3.2%
Promise.race (5 resolved)	4,002 ops/sec [3,887..4,313] → 4,380 ops/sec [3,914..5,535]	~ overlap (+9.5%)	4,492 ops/sec [4,469..4,502] → 4,485 ops/sec [4,259..4,602]	~ overlap (-0.2%)
Promise.allSettled (5 mixed)	2,892 ops/sec [2,841..2,911] → 2,948 ops/sec [2,548..3,327]	~ overlap (+1.9%)	3,325 ops/sec [3,316..3,338] → 3,431 ops/sec [3,303..4,406]	~ overlap (+3.2%)
Promise.any (5 mixed)	3,431 ops/sec [3,387..3,453] → 3,687 ops/sec [3,498..3,865]	🟢 +7.5%	4,127 ops/sec [3,927..4,651] → 4,080 ops/sec [3,979..4,953]	~ overlap (-1.1%)

property-access.js — Interp: 🟢 1, 4 unch. · avg -1.2% · Bytecode: 5 unch. · avg +10.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
class instance fields across 1000 instances	115 ops/sec [112..117] → 113 ops/sec [109..121]	~ overlap (-1.9%)	1,100 ops/sec [1,044..1,266] → 1,071 ops/sec [1,017..1,288]	~ overlap (-2.7%)
object literal fields across 1000 literals	117 ops/sec [112..117] → 114 ops/sec [110..117]	~ overlap (-2.0%)	1,059 ops/sec [1,016..1,427] → 1,055 ops/sec [1,008..1,210]	~ overlap (-0.4%)
mixed-shape literals across 1000 literals	117 ops/sec [113..118] → 117 ops/sec [116..119]	~ overlap (+0.8%)	752 ops/sec [748..896] → 1,081 ops/sec [712..1,292]	~ overlap (+43.7%)
own-class method across 1000 instances	71 ops/sec [71..71] → 73 ops/sec [73..73]	🟢 +3.9%	529 ops/sec [520..542] → 553 ops/sec [514..648]	~ overlap (+4.5%)
inherited method across 1000 instances	85 ops/sec [80..90] → 79 ops/sec [77..89]	~ overlap (-6.6%)	568 ops/sec [551..595] → 602 ops/sec [552..719]	~ overlap (+6.0%)

regexp.js — Interp: 13 unch. · avg +1.1% · Bytecode: 🔴 2, 11 unch. · avg -1.6%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
regex literal creation	7,285 ops/sec [6,909..7,340] → 7,434 ops/sec [7,097..7,926]	~ overlap (+2.0%)	229,429 ops/sec [213,610..243,522] → 221,918 ops/sec [209,126..264,717]	~ overlap (-3.3%)
new RegExp(pattern, flags)	7,182 ops/sec [6,602..7,876] → 6,895 ops/sec [6,818..6,944]	~ overlap (-4.0%)	7,819 ops/sec [7,436..8,685] → 7,410 ops/sec [7,275..7,540]	~ overlap (-5.2%)
RegExp(existingRegex) returns the same regex	131,744 ops/sec [130,049..140,550] → 135,941 ops/sec [134,579..138,160]	~ overlap (+3.2%)	224,533 ops/sec [221,710..236,452] → 221,007 ops/sec [217,857..226,279]	~ overlap (-1.6%)
test() on a global regex	57,328 ops/sec [57,182..57,811] → 59,406 ops/sec [56,777..79,451]	~ overlap (+3.6%)	85,991 ops/sec [82,340..87,079] → 85,872 ops/sec [80,906..93,738]	~ overlap (-0.1%)
exec() with capture groups	33,824 ops/sec [33,175..41,272] → 33,391 ops/sec [32,358..34,869]	~ overlap (-1.3%)	43,829 ops/sec [43,175..44,817] → 45,756 ops/sec [41,482..52,235]	~ overlap (+4.4%)
toString()	44,568 ops/sec [43,075..45,268] → 46,117 ops/sec [44,650..48,192]	~ overlap (+3.5%)	58,865 ops/sec [55,139..60,842] → 57,519 ops/sec [55,385..68,892]	~ overlap (-2.3%)
match() with global regex	20,862 ops/sec [20,754..21,488] → 21,845 ops/sec [20,438..22,092]	~ overlap (+4.7%)	27,256 ops/sec [27,158..27,697] → 27,541 ops/sec [26,727..35,122]	~ overlap (+1.0%)
match() with many global results	1,024 ops/sec [999..1,033] → 1,061 ops/sec [1,000..1,068]	~ overlap (+3.6%)	1,179 ops/sec [1,172..1,219] → 1,171 ops/sec [1,076..1,198]	~ overlap (-0.6%)
matchAll() with capture groups	6,767 ops/sec [6,631..6,936] → 7,197 ops/sec [6,859..7,238]	~ overlap (+6.3%)	11,146 ops/sec [10,886..12,254] → 10,542 ops/sec [10,384..10,909]	~ overlap (-5.4%)
replace() with global regex	19,447 ops/sec [19,279..19,855] → 19,598 ops/sec [19,487..19,677]	~ overlap (+0.8%)	26,254 ops/sec [26,134..26,271] → 26,291 ops/sec [25,791..26,994]	~ overlap (+0.1%)
replace() with many global results	828 ops/sec [818..841] → 806 ops/sec [800..865]	~ overlap (-2.6%)	939 ops/sec [926..961] → 957 ops/sec [940..962]	~ overlap (+1.9%)
search() with regex	39,189 ops/sec [37,962..41,795] → 38,372 ops/sec [37,619..45,151]	~ overlap (-2.1%)	54,664 ops/sec [53,980..54,978] → 52,607 ops/sec [50,281..53,070]	🔴 -3.8%
split() with regex separator	9,459 ops/sec [9,361..9,513] → 9,086 ops/sec [8,899..9,840]	~ overlap (-3.9%)	11,035 ops/sec [10,662..11,176] → 10,403 ops/sec [10,278..10,601]	🔴 -5.7%

strings.js — Interp: 🟢 3, 16 unch. · avg +0.4% · Bytecode: 🟢 7, 12 unch. · avg +3.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
string concatenation	84,560 ops/sec [71,419..86,875] → 72,603 ops/sec [69,924..73,048]	~ overlap (-14.1%)	662,148 ops/sec [646,410..690,836] → 663,097 ops/sec [644,458..673,561]	~ overlap (+0.1%)
template literal	128,667 ops/sec [124,621..148,492] → 127,629 ops/sec [122,524..131,502]	~ overlap (-0.8%)	623,278 ops/sec [599,346..697,488] → 589,731 ops/sec [569,947..622,185]	~ overlap (-5.4%)
string repeat	87,004 ops/sec [83,978..97,966] → 85,660 ops/sec [81,872..135,927]	~ overlap (-1.5%)	120,078 ops/sec [117,634..121,988] → 125,892 ops/sec [122,437..139,901]	🟢 +4.8%
split and join	36,939 ops/sec [35,763..38,064] → 35,953 ops/sec [35,139..39,319]	~ overlap (-2.7%)	55,182 ops/sec [54,414..66,278] → 59,013 ops/sec [56,349..62,927]	~ overlap (+6.9%)
indexOf and includes	36,361 ops/sec [36,287..44,256] → 36,211 ops/sec [35,323..44,231]	~ overlap (-0.4%)	56,721 ops/sec [55,407..59,060] → 57,664 ops/sec [56,311..70,785]	~ overlap (+1.7%)
toUpperCase and toLowerCase	35,109 ops/sec [34,818..35,211] → 35,888 ops/sec [34,867..39,261]	~ overlap (+2.2%)	47,969 ops/sec [47,285..51,405] → 49,814 ops/sec [49,089..50,226]	~ overlap (+3.8%)
slice and substring	34,496 ops/sec [33,415..35,001] → 33,651 ops/sec [32,520..45,538]	~ overlap (-2.4%)	51,638 ops/sec [50,665..58,426] → 54,103 ops/sec [52,421..56,668]	~ overlap (+4.8%)
trim operations	39,319 ops/sec [37,909..46,845] → 38,255 ops/sec [37,399..42,839]	~ overlap (-2.7%)	58,125 ops/sec [57,850..58,778] → 59,330 ops/sec [58,207..62,350]	~ overlap (+2.1%)
replace and replaceAll	44,010 ops/sec [43,440..53,385] → 42,482 ops/sec [41,498..43,751]	~ overlap (-3.5%)	66,086 ops/sec [65,537..66,554] → 67,893 ops/sec [67,009..67,999]	🟢 +2.7%
startsWith and endsWith	28,988 ops/sec [28,557..30,420] → 28,937 ops/sec [28,180..30,921]	~ overlap (-0.2%)	44,576 ops/sec [43,960..45,277] → 46,003 ops/sec [45,550..46,980]	🟢 +3.2%
padStart and padEnd	44,167 ops/sec [43,436..54,114] → 43,663 ops/sec [43,325..47,798]	~ overlap (-1.1%)	67,772 ops/sec [67,025..68,971] → 71,357 ops/sec [70,439..72,073]	🟢 +5.3%
identity tag, no substitutions	95,236 ops/sec [95,129..95,857] → 98,074 ops/sec [97,418..98,410]	🟢 +3.0%	179,973 ops/sec [178,757..181,696] → 180,232 ops/sec [177,479..188,812]	~ overlap (+0.1%)
tag with 1 substitution	20,696 ops/sec [20,336..21,535] → 22,608 ops/sec [22,218..23,188]	🟢 +9.2%	35,029 ops/sec [32,798..41,044] → 36,410 ops/sec [36,088..36,561]	~ overlap (+3.9%)
tag with 3 substitutions	12,422 ops/sec [11,953..13,649] → 12,784 ops/sec [12,164..13,973]	~ overlap (+2.9%)	20,623 ops/sec [20,058..20,748] → 22,119 ops/sec [21,587..22,572]	🟢 +7.3%
tag with 6 substitutions	7,280 ops/sec [7,178..7,983] → 7,720 ops/sec [7,667..7,785]	~ overlap (+6.0%)	12,153 ops/sec [11,946..12,176] → 13,024 ops/sec [12,805..13,123]	🟢 +7.2%
String.raw, no substitutions	87,807 ops/sec [84,900..89,793] → 86,781 ops/sec [84,525..87,275]	~ overlap (-1.2%)	94,957 ops/sec [93,714..95,781] → 96,767 ops/sec [94,121..110,781]	~ overlap (+1.9%)
String.raw, 2 substitutions	58,627 ops/sec [57,937..59,068] → 58,798 ops/sec [57,076..59,141]	~ overlap (+0.3%)	85,161 ops/sec [84,886..85,738] → 84,775 ops/sec [82,345..85,346]	~ overlap (-0.5%)
tag accessing .raw array	35,449 ops/sec [35,346..35,549] → 37,563 ops/sec [36,356..38,956]	🟢 +6.0%	53,421 ops/sec [52,608..53,953] → 55,513 ops/sec [53,614..55,677]	~ overlap (+3.9%)
method as tag (this binding)	14,890 ops/sec [14,798..14,921] → 16,102 ops/sec [14,724..16,135]	~ overlap (+8.1%)	25,772 ops/sec [25,683..26,003] → 27,246 ops/sec [26,974..27,468]	🟢 +5.7%

temporal.js — Interp: 6 unch. · avg -0.3% · Bytecode: 🟢 1, 5 unch. · avg +2.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
PlainDate.add({ months: 1 })	38,703 ops/sec [36,478..40,972] → 38,921 ops/sec [37,103..39,670]	~ overlap (+0.6%)	45,166 ops/sec [44,899..54,781] → 48,987 ops/sec [45,944..56,334]	~ overlap (+8.5%)
PlainDate.until(..., { largestUnit: 'months' })	44,432 ops/sec [42,979..45,250] → 43,481 ops/sec [41,520..44,596]	~ overlap (-2.1%)	56,313 ops/sec [55,720..57,197] → 59,345 ops/sec [57,593..61,363]	🟢 +5.4%
Duration.total days relative to PlainDate	36,518 ops/sec [36,268..37,670] → 37,323 ops/sec [36,180..47,711]	~ overlap (+2.2%)	45,991 ops/sec [45,143..46,703] → 47,177 ops/sec [46,155..65,465]	~ overlap (+2.6%)
Duration.round to hours	30,626 ops/sec [29,741..30,816] → 30,033 ops/sec [29,164..34,789]	~ overlap (-1.9%)	37,122 ops/sec [36,507..37,373] → 37,598 ops/sec [36,980..44,949]	~ overlap (+1.3%)
ZonedDateTime.from named time zone	8,691 ops/sec [8,481..10,733] → 8,612 ops/sec [8,533..8,840]	~ overlap (-0.9%)	10,270 ops/sec [10,142..14,390] → 10,277 ops/sec [10,047..10,961]	~ overlap (+0.1%)
ZonedDateTime.since across DST	9,631 ops/sec [9,345..11,390] → 9,673 ops/sec [9,640..10,309]	~ overlap (+0.4%)	11,706 ops/sec [11,620..11,961] → 11,686 ops/sec [11,528..12,598]	~ overlap (-0.2%)

tsv.js — Interp: 🟢 4, 5 unch. · avg +2.5% · Bytecode: 9 unch. · avg -2.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple 3-column TSV	32,190 ops/sec [31,980..32,405] → 33,784 ops/sec [33,635..34,082]	🟢 +5.0%	41,858 ops/sec [40,954..44,527] → 41,182 ops/sec [40,551..47,057]	~ overlap (-1.6%)
parse 10-row TSV	9,266 ops/sec [9,007..9,423] → 9,771 ops/sec [9,741..9,856]	🟢 +5.4%	11,081 ops/sec [10,942..11,233] → 10,802 ops/sec [10,565..11,099]	~ overlap (-2.5%)
parse 100-row TSV	1,531 ops/sec [1,472..1,656] → 1,514 ops/sec [1,487..1,639]	~ overlap (-1.1%)	1,715 ops/sec [1,653..1,728] → 1,702 ops/sec [1,686..1,831]	~ overlap (-0.7%)
parse TSV with backslash-escaped fields	8,335 ops/sec [7,700..9,030] → 7,836 ops/sec [7,726..7,967]	~ overlap (-6.0%)	9,089 ops/sec [8,969..10,772] → 9,054 ops/sec [8,787..9,578]	~ overlap (-0.4%)
parse without headers (array of arrays)	4,464 ops/sec [4,166..5,173] → 4,556 ops/sec [4,273..4,804]	~ overlap (+2.1%)	4,960 ops/sec [4,899..5,632] → 5,002 ops/sec [4,929..5,066]	~ overlap (+0.9%)
stringify array of objects	11,603 ops/sec [11,399..11,678] → 11,550 ops/sec [11,308..11,589]	~ overlap (-0.5%)	14,526 ops/sec [14,500..14,650] → 14,550 ops/sec [14,396..15,671]	~ overlap (+0.2%)
stringify array of arrays	3,012 ops/sec [2,982..3,236] → 2,996 ops/sec [2,958..3,403]	~ overlap (-0.5%)	3,584 ops/sec [3,553..3,603] → 3,537 ops/sec [3,460..3,717]	~ overlap (-1.3%)
stringify with values needing escaping	9,508 ops/sec [9,380..9,593] → 10,205 ops/sec [10,166..10,275]	🟢 +7.3%	12,397 ops/sec [11,785..12,758] → 11,611 ops/sec [11,525..13,993]	~ overlap (-6.3%)
parse then stringify	3,464 ops/sec [3,450..3,478] → 3,829 ops/sec [3,788..3,876]	🟢 +10.5%	4,373 ops/sec [3,991..4,549] → 4,054 ops/sec [3,998..4,074]	~ overlap (-7.3%)

typed-arrays.js — Interp: 🟢 8, 14 unch. · avg +23.4% · Bytecode: 🟢 15, 7 unch. · avg +8.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
new Int32Array(0)	85,567 ops/sec [82,905..95,963] → 83,503 ops/sec [83,046..84,915]	~ overlap (-2.4%)	114,594 ops/sec [114,081..114,791] → 119,041 ops/sec [118,074..119,397]	🟢 +3.9%
new Int32Array(100)	79,539 ops/sec [78,364..89,822] → 80,803 ops/sec [78,736..80,831]	~ overlap (+1.6%)	105,862 ops/sec [105,587..105,945] → 111,368 ops/sec [109,377..118,075]	🟢 +5.2%
new Int32Array(1000)	62,938 ops/sec [62,050..70,390] → 66,934 ops/sec [65,614..69,862]	~ overlap (+6.3%)	79,575 ops/sec [78,371..79,630] → 82,144 ops/sec [81,350..82,538]	🟢 +3.2%
new Float64Array(100)	76,577 ops/sec [75,539..90,258] → 80,515 ops/sec [79,826..103,466]	~ overlap (+5.1%)	101,529 ops/sec [101,325..102,017] → 106,869 ops/sec [105,344..108,986]	🟢 +5.3%
Int32Array.from([...])	1,189 ops/sec [1,181..1,216] → 1,210 ops/sec [977..1,478]	~ overlap (+1.8%)	1,219 ops/sec [1,190..1,240] → 1,284 ops/sec [1,268..1,727]	🟢 +5.3%
Int32Array.of(1, 2, 3, 4, 5)	57,602 ops/sec [57,338..60,900] → 58,315 ops/sec [57,496..58,855]	~ overlap (+1.2%)	71,875 ops/sec [70,981..77,683] → 74,520 ops/sec [73,385..74,722]	~ overlap (+3.7%)
sequential write 100 elements	968 ops/sec [947..1,072] → 972 ops/sec [967..978]	~ overlap (+0.4%)	9,680 ops/sec [9,588..9,871] → 9,930 ops/sec [9,497..9,956]	~ overlap (+2.6%)
sequential read 100 elements	979 ops/sec [973..1,011] → 992 ops/sec [970..1,089]	~ overlap (+1.3%)	9,870 ops/sec [9,830..9,908] → 10,166 ops/sec [10,042..10,277]	🟢 +3.0%
Float64Array write 100 elements	834 ops/sec [832..838] → 858 ops/sec [855..883]	🟢 +2.9%	7,525 ops/sec [7,457..7,596] → 7,733 ops/sec [7,724..7,781]	🟢 +2.8%
fill(42)	6,548 ops/sec [6,488..6,807] → 6,442 ops/sec [6,431..6,536]	~ overlap (-1.6%)	7,219 ops/sec [7,142..7,271] → 7,428 ops/sec [7,133..7,451]	~ overlap (+2.9%)
slice()	43,825 ops/sec [43,368..44,580] → 67,357 ops/sec [42,958..67,995]	~ overlap (+53.7%)	54,653 ops/sec [53,720..55,046] → 56,938 ops/sec [56,285..57,315]	🟢 +4.2%
map(x => x * 2)	1,780 ops/sec [1,752..2,136] → 2,931 ops/sec [2,918..2,939]	🟢 +64.7%	2,143 ops/sec [2,137..2,146] → 2,221 ops/sec [2,210..2,237]	🟢 +3.6%
filter(x => x > 50)	1,765 ops/sec [1,743..1,799] → 2,920 ops/sec [2,894..2,936]	🟢 +65.4%	2,306 ops/sec [2,271..2,729] → 2,369 ops/sec [2,359..2,618]	~ overlap (+2.7%)
reduce (sum)	1,897 ops/sec [1,825..1,906] → 2,997 ops/sec [2,979..3,006]	🟢 +58.0%	2,150 ops/sec [2,141..2,157] → 2,150 ops/sec [2,142..2,187]	~ overlap (+0.0%)
sort()	21,286 ops/sec [21,143..21,377] → 36,272 ops/sec [35,167..36,627]	🟢 +70.4%	23,837 ops/sec [22,987..25,144] → 23,184 ops/sec [22,937..23,365]	~ overlap (-2.7%)
indexOf()	25,737 ops/sec [25,010..28,211] → 41,640 ops/sec [24,864..41,877]	~ overlap (+61.8%)	28,608 ops/sec [28,353..29,982] → 29,074 ops/sec [28,892..29,316]	~ overlap (+1.6%)
reverse()	30,305 ops/sec [30,173..30,474] → 51,378 ops/sec [28,951..51,601]	~ overlap (+69.5%)	33,826 ops/sec [33,659..33,995] → 53,209 ops/sec [34,010..54,405]	🟢 +57.3%
create view over existing buffer	102,236 ops/sec [97,142..107,370] → 156,124 ops/sec [155,392..156,893]	🟢 +52.7%	150,715 ops/sec [149,671..151,577] → 246,667 ops/sec [241,036..247,330]	🟢 +63.7%
subarray()	77,092 ops/sec [76,492..77,344] → 78,853 ops/sec [78,462..79,118]	🟢 +2.3%	97,211 ops/sec [96,567..97,689] → 101,199 ops/sec [99,916..101,782]	🟢 +4.1%
set() from array	101,821 ops/sec [101,483..102,369] → 104,130 ops/sec [103,792..104,985]	🟢 +2.3%	126,513 ops/sec [125,635..127,044] → 129,277 ops/sec [128,543..129,804]	🟢 +2.2%
for-of loop	2,175 ops/sec [2,159..2,181] → 2,149 ops/sec [2,140..2,166]	~ overlap (-1.2%)	19,300 ops/sec [19,198..19,397] → 19,638 ops/sec [19,564..19,705]	🟢 +1.8%
spread into array	8,919 ops/sec [8,838..8,982] → 8,823 ops/sec [8,788..8,861]	~ overlap (-1.1%)	30,103 ops/sec [29,990..30,196] → 31,255 ops/sec [30,686..31,545]	🟢 +3.8%

uint8array-encoding.js — Interp: 🟢 2, 🔴 1, 15 unch. · avg +0.6% · Bytecode: 🟢 2, 🔴 11, 5 unch. · avg +1.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
short (5 bytes)	114,978 ops/sec [109,879..118,676] → 110,227 ops/sec [109,367..111,466]	~ overlap (-4.1%)	148,245 ops/sec [147,340..148,557] → 143,655 ops/sec [142,355..144,887]	🔴 -3.1%
medium (450 bytes)	77,972 ops/sec [76,582..81,213] → 77,072 ops/sec [76,041..78,019]	~ overlap (-1.2%)	95,287 ops/sec [92,629..96,107] → 92,414 ops/sec [90,702..92,558]	🔴 -3.0%
large (4096 bytes)	22,039 ops/sec [21,713..22,117] → 21,931 ops/sec [21,550..22,370]	~ overlap (-0.5%)	24,088 ops/sec [23,780..24,177] → 23,380 ops/sec [23,326..23,754]	🔴 -2.9%
base64url alphabet	59,051 ops/sec [58,239..60,523] → 61,573 ops/sec [60,379..61,821]	~ overlap (+4.3%)	73,390 ops/sec [72,114..78,398] → 69,643 ops/sec [69,227..70,094]	🔴 -5.1%
omitPadding	79,550 ops/sec [78,886..83,829] → 81,069 ops/sec [79,721..82,312]	~ overlap (+1.9%)	98,380 ops/sec [96,457..99,553] → 95,396 ops/sec [93,302..95,899]	🔴 -3.0%
short (8 chars)	90,476 ops/sec [89,786..90,677] → 98,543 ops/sec [89,053..108,347]	~ overlap (+8.9%)	108,377 ops/sec [107,634..108,791] → 106,851 ops/sec [105,285..108,985]	~ overlap (-1.4%)
medium (600 chars)	17,560 ops/sec [17,325..19,085] → 17,610 ops/sec [17,544..17,719]	~ overlap (+0.3%)	20,028 ops/sec [19,910..20,216] → 19,858 ops/sec [19,468..19,904]	🔴 -0.8%
large (5464 chars)	2,350 ops/sec [2,331..2,371] → 2,280 ops/sec [2,250..2,296]	🔴 -3.0%	2,619 ops/sec [2,598..2,640] → 2,627 ops/sec [2,622..2,686]	~ overlap (+0.3%)
short (5 bytes)	114,798 ops/sec [114,433..116,028] → 111,483 ops/sec [110,050..118,609]	~ overlap (-2.9%)	194,900 ops/sec [156,633..263,613] → 153,336 ops/sec [147,393..155,697]	🔴 -21.3%
medium (450 bytes)	70,735 ops/sec [69,986..71,296] → 71,963 ops/sec [71,794..72,408]	🟢 +1.7%	139,520 ops/sec [138,847..140,290] → 83,931 ops/sec [83,090..138,652]	🔴 -39.8%
large (4096 bytes)	16,902 ops/sec [16,813..17,280] → 17,323 ops/sec [17,137..18,524]	~ overlap (+2.5%)	30,236 ops/sec [30,097..30,415] → 29,727 ops/sec [29,695..29,855]	🔴 -1.7%
short (10 chars)	102,498 ops/sec [100,637..102,773] → 103,825 ops/sec [103,426..103,951]	🟢 +1.3%	196,341 ops/sec [194,669..197,470] → 185,147 ops/sec [184,974..185,591]	🔴 -5.7%
medium (900 chars)	75,348 ops/sec [74,260..124,793] → 76,371 ops/sec [75,270..86,504]	~ overlap (+1.4%)	86,986 ops/sec [85,696..88,406] → 138,054 ops/sec [135,775..138,527]	🟢 +58.7%
large (8192 chars)	24,193 ops/sec [23,230..24,511] → 24,290 ops/sec [23,066..24,430]	~ overlap (+0.4%)	26,634 ops/sec [25,173..26,823] → 43,642 ops/sec [42,418..43,870]	🟢 +63.9%
setFromBase64 (450 bytes)	17,206 ops/sec [17,023..17,480] → 23,762 ops/sec [16,395..29,458]	~ overlap (+38.1%)	19,394 ops/sec [19,291..19,443] → 19,465 ops/sec [19,123..30,677]	~ overlap (+0.4%)
setFromHex (450 bytes)	20,852 ops/sec [20,800..20,987] → 21,274 ops/sec [20,466..35,011]	~ overlap (+2.0%)	23,207 ops/sec [22,865..25,798] → 24,169 ops/sec [22,872..36,246]	~ overlap (+4.1%)
toBase64 → fromBase64 (450 bytes)	15,632 ops/sec [15,477..15,644] → 15,120 ops/sec [14,810..15,743]	~ overlap (-3.3%)	27,382 ops/sec [27,307..27,452] → 26,961 ops/sec [17,878..27,308]	~ overlap (-1.5%)
toHex → fromHex (450 bytes)	69,228 ops/sec [40,662..69,767] → 43,130 ops/sec [42,759..43,270]	~ overlap (-37.7%)	77,291 ops/sec [75,400..77,773] → 74,357 ops/sec [73,836..74,929]	🔴 -3.8%

weak-collections.js — Interp: 🟢 5, 🔴 8, 2 unch. · avg -16.7% · Bytecode: 🟢 9, 🔴 1, 5 unch. · avg +23.7%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
constructor from 50 entries	6,996 ops/sec [6,883..7,032] → 7,429 ops/sec [7,213..7,941]	🟢 +6.2%	8,484 ops/sec [8,214..8,821] → 8,838 ops/sec [8,375..8,998]	~ overlap (+4.2%)
set 50 object keys	2,466 ops/sec [2,352..2,663] → 2,727 ops/sec [2,664..2,747]	🟢 +10.6%	3,266 ops/sec [3,231..3,294] → 3,554 ops/sec [3,513..3,625]	🟢 +8.8%
get lookups (50 entries)	32,509 ops/sec [32,222..32,591] → 33,244 ops/sec [33,189..33,333]	🟢 +2.3%	65,844 ops/sec [65,398..67,733] → 64,289 ops/sec [62,835..65,046]	🔴 -2.4%
has checks (50 entries)	68,128 ops/sec [67,785..68,743] → 44,138 ops/sec [43,357..44,465]	🔴 -35.2%	82,665 ops/sec [82,247..83,080] → 144,248 ops/sec [143,044..145,602]	🟢 +74.5%
delete entries	3,561 ops/sec [3,522..3,598] → 2,530 ops/sec [2,503..2,546]	🔴 -28.9%	3,152 ops/sec [3,099..3,165] → 5,726 ops/sec [5,686..5,789]	🟢 +81.7%
non-registered symbol keys	8,502 ops/sec [8,486..8,566] → 6,161 ops/sec [6,110..6,236]	🔴 -27.5%	7,581 ops/sec [7,545..7,715] → 13,926 ops/sec [13,744..14,028]	🟢 +83.7%
getOrInsert	3,313 ops/sec [3,288..3,330] → 2,391 ops/sec [2,378..2,406]	🔴 -27.8%	3,038 ops/sec [3,016..3,061] → 3,507 ops/sec [3,325..5,620]	🟢 +15.4%
getOrInsertComputed	1,947 ops/sec [1,927..1,968] → 1,426 ops/sec [1,422..1,441]	🔴 -26.8%	1,656 ops/sec [1,653..1,662] → 1,735 ops/sec [1,705..1,760]	🟢 +4.8%
forced gc live-key retention	1,237 ops/sec [687..1,434] → 909 ops/sec [860..989]	~ overlap (-26.5%)	952 ops/sec [840..1,046] → 676 ops/sec [643..1,054]	~ overlap (-29.0%)
constructor from 50 values	13,662 ops/sec [13,194..13,686] → 8,949 ops/sec [8,813..9,039]	🔴 -34.5%	10,308 ops/sec [10,044..11,197] → 10,278 ops/sec [9,975..10,868]	~ overlap (-0.3%)
add 50 object values	3,974 ops/sec [3,950..4,012] → 2,898 ops/sec [2,877..2,904]	🔴 -27.1%	3,452 ops/sec [3,430..3,498] → 3,849 ops/sec [3,833..3,881]	🟢 +11.5%
has checks (50 values)	68,634 ops/sec [68,448..69,045] → 44,560 ops/sec [44,237..54,254]	🔴 -35.1%	84,059 ops/sec [82,957..89,416] → 86,092 ops/sec [85,744..86,723]	~ overlap (+2.4%)
delete values	10,730 ops/sec [10,365..10,768] → 11,247 ops/sec [11,140..11,508]	🟢 +4.8%	9,118 ops/sec [8,668..9,332] → 14,734 ops/sec [14,699..14,858]	🟢 +61.6%
non-registered symbol values	8,851 ops/sec [8,772..8,978] → 10,106 ops/sec [9,913..10,223]	🟢 +14.2%	7,843 ops/sec [7,829..7,877] → 8,883 ops/sec [8,835..14,715]	🟢 +13.3%
forced gc pruning smoke	1,496 ops/sec [1,459..1,498] → 1,212 ops/sec [923..1,709]	~ overlap (-19.0%)	767 ops/sec [682..1,077] → 963 ops/sec [829..1,119]	~ overlap (+25.6%)

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]

Suite Timing

Test Runner (interpreted: 12,819 passed; bytecode: 12,819 passed)

Metric	Interpreted	Bytecode
Total	12819	12819
Passed	12819 ✅	12819 ✅
Workers	4	4
Test Duration	20.65s	20.85s
Lex (cumulative)	2.09s	2.17s
Parse (cumulative)	1.12s	1.16s
Compile (cumulative)	—	1.46s
Execute (cumulative)	1.27s	20.03s
Engine Total (cumulative)	4.48s	24.82s
Lex (avg/worker)	522.1ms	541.9ms
Parse (avg/worker)	280.2ms	290.3ms
Compile (avg/worker)	—	365.9ms
Execute (avg/worker)	318.1ms	5.01s
Engine Total (avg/worker)	1.12s	6.20s

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	59.61 MiB	54.78 MiB
GC Peak Live	211.92 MiB	169.31 MiB
GC Allocated During Run	702.44 MiB	613.47 MiB
GC Limit	7.81 GiB	7.81 GiB
GC Collections	1,010	1,016
GC Collected Objects	5,477,711	4,786,159
Heap Start Allocated	372.4 KiB	372.4 KiB
Heap End Allocated	3.19 MiB	3.19 MiB
Heap Delta Allocated	2.83 MiB	2.83 MiB
Heap Delta Free	2.39 MiB	2.39 MiB

Benchmarks (interpreted: 440; bytecode: 440)

Metric	Interpreted	Bytecode
Total	440	440
Workers	4	4
Duration	3.04min	3.01min

Memory

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

Metric	Interpreted	Bytecode
GC Live	85.0 KiB	85.0 KiB
GC Peak Live	378.20 MiB	296.10 MiB
GC Allocated During Run	18.66 GiB	14.24 GiB
GC Limit	7.81 GiB	7.81 GiB
GC Collections	5,812	5,213
GC Collected Objects	212,886,755	193,445,861
Heap Start Allocated	1.37 MiB	1.37 MiB
Heap End Allocated	1.37 MiB	1.37 MiB
Heap Delta Allocated	3.2 KiB	3.2 KiB

Boot

Metric	Interpreted	Bytecode
Boot (median)	7.6ms	7.8ms
Boot (min)	7.5ms	7.6ms

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]

AWFY Results

Target	Status	Goccia main	Goccia PR	QuickJS 2026-06-04	NodeJS v26.8.1	Δ PR vs main
Bounce	pass	17.11ms	17.28ms	1.09ms	0.99ms	~ overlap (-1.03%)
CD	pass	186.98ms	186.02ms	9.98ms	9.42ms	~ overlap (+0.52%)
DeltaBlue	pass	3.93ms	3.96ms	298.31µs	1.55ms	~ overlap (-0.75%)
Havlak	pass	73.05s	73.22s	4190.29ms	190.34ms	🔴 -0.24%
Json	pass	314.90ms	320.66ms	14.17ms	4.39ms	~ overlap (-1.83%)
List	pass	11.65ms	11.90ms	1.02ms	0.84ms	~ overlap (-2.16%)
Mandelbrot	pass	30.18µs	30.43µs	6.17µs	89.66µs	~ overlap (-0.80%)
NBody	pass	419.91µs	386.28µs	32.24µs	368.79µs	~ overlap (+8.01%)
Permute	pass	35.23ms	34.78ms	1.96ms	0.82ms	🟢 +1.28%
Queens	pass	17.83ms	17.84ms	1.33ms	1.12ms	~ overlap (-0.04%)
Richards	pass	562.03ms	565.76ms	52.27ms	6.69ms	~ overlap (-0.66%)
Sieve	pass	12.66ms	12.00ms	0.59ms	0.55ms	🟢 +5.26%
Storage	pass	32.83ms	32.63ms	3.11ms	1.11ms	~ overlap (+0.61%)
Towers	pass	45.96ms	46.43ms	3.16ms	1.19ms	~ overlap (-1.02%)

Geomean Ratios

Ratio (row / column)	Goccia main	Goccia PR	QuickJS 2026-06-04	NodeJS v26.8.1
Goccia main	1.000	1.006	13.839	17.157
Goccia PR	0.995	1.000	13.763	17.063
QuickJS 2026-06-04	0.072	0.073	1.000	1.240
NodeJS v26.8.1	0.058	0.059	0.807	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

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

Category	Run	Passed	Δ Pass	Failed	Timeouts	Δ Timeout	Wrap-Infra	Pass-rate	Δ Rate
built-ins	23,812	23,719	±0	93	0	±0	0	99.6%	±0pp
harness	116	116	±0	0	0	±0	0	100.0%	±0pp
intl402	3,357	3,344	±0	12	1	±0	0	99.6%	±0pp
language	23,726	23,719	±0	7	0	±0	0	100.0%	±0pp
staging	1,483	1,387	-1	85	11	+1	0	93.5%	-0.1pp
total	52,494	52,285	-1	197	12	+1	0	99.6%	±0pp

Areas closest to 100%

Area	Pass rate	Δ vs main	Passing
language/expressions	100.0%	±0pp	11,101 / 11,102
intl402/Temporal	100.0%	±0pp	2,028 / 2,029
language/statements	99.9%	±0pp	9,341 / 9,347

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

New timeouts (2):

• staging/sm/regress/regress-610026.js
• staging/sm/TypedArray/element-setting-converts-using-ToNumber.js

Resolved timeouts (1):

• staging/sm/extensions/recursion.js

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