chore(tc39-mcp): bump pin to v0.5.0

[github-actions]

Automated bump of the tc39-mcp npm pin to v0.5.0.

This updates agent spec-lookup tooling only. It does not change
GocciaScript runtime behavior, build outputs, or CI conformance
gates.

Cron: weekly, Mondays 07:30 UTC. See .github/workflows/tc39-mcp-bump.yml.

[vercel]

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

1 Skipped Deployment

Project	Deployment	Actions	Updated (UTC)
gocciascript-homepage	Ignored	Preview	Jun 29, 2026 9:09am

[github-actions]

Benchmark Results

437 benchmarks · PR vs same-runner main build

Interpreted: 🟢 41 improved · 🔴 40 regressed · 356 unchanged · avg +1.2%
Bytecode: 🟢 33 improved · 🔴 28 regressed · 376 unchanged · avg +0.4%

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

arraybuffer.js — Interp: 🟢 1, 🔴 2, 11 unch. · avg +1.1% · Bytecode: 🔴 1, 13 unch. · avg -0.8%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
create ArrayBuffer(0)	123,973 ops/sec [95,482..145,827] → 125,073 ops/sec [114,686..130,216]	~ overlap (+0.9%)	153,036 ops/sec [140,262..175,284] → 147,367 ops/sec [119,721..148,643]	~ overlap (-3.7%)
create ArrayBuffer(64)	122,223 ops/sec [119,836..122,538] → 124,302 ops/sec [121,700..131,414]	~ overlap (+1.7%)	157,813 ops/sec [145,014..173,098] → 146,175 ops/sec [143,057..185,271]	~ overlap (-7.4%)
create ArrayBuffer(1024)	111,791 ops/sec [110,253..129,608] → 113,216 ops/sec [111,373..122,404]	~ overlap (+1.3%)	131,695 ops/sec [129,541..161,589] → 130,279 ops/sec [128,232..163,242]	~ overlap (-1.1%)
create ArrayBuffer(8192)	75,832 ops/sec [74,730..76,548] → 75,535 ops/sec [73,578..77,931]	~ overlap (-0.4%)	78,002 ops/sec [74,771..88,862] → 75,852 ops/sec [73,139..78,099]	~ overlap (-2.8%)
slice full buffer (64 bytes)	111,207 ops/sec [99,102..115,419] → 108,526 ops/sec [100,918..116,735]	~ overlap (-2.4%)	120,188 ops/sec [117,008..126,072] → 117,731 ops/sec [116,403..118,921]	~ overlap (-2.0%)
slice half buffer (512 of 1024 bytes)	94,550 ops/sec [64,506..96,119] → 102,808 ops/sec [94,372..115,587]	~ overlap (+8.7%)	112,449 ops/sec [110,930..113,385] → 111,534 ops/sec [110,780..126,078]	~ overlap (-0.8%)
slice with negative indices	87,767 ops/sec [85,955..88,292] → 89,990 ops/sec [88,055..95,863]	~ overlap (+2.5%)	116,188 ops/sec [115,304..119,097] → 112,738 ops/sec [111,953..118,743]	~ overlap (-3.0%)
slice empty range	98,527 ops/sec [97,784..101,300] → 97,897 ops/sec [97,653..107,138]	~ overlap (-0.6%)	118,515 ops/sec [117,947..118,744] → 116,058 ops/sec [115,256..116,524]	🔴 -2.1%
byteLength access	294,152 ops/sec [289,808..295,086] → 293,743 ops/sec [290,864..298,069]	~ overlap (-0.1%)	344,211 ops/sec [341,748..391,013] → 341,436 ops/sec [331,020..343,502]	~ overlap (-0.8%)
Symbol.toStringTag access	220,754 ops/sec [219,740..221,554] → 237,234 ops/sec [221,903..241,210]	🟢 +7.5%	242,230 ops/sec [241,212..246,288] → 244,945 ops/sec [244,435..246,272]	~ overlap (+1.1%)
ArrayBuffer.isView	179,136 ops/sec [171,433..203,039] → 175,802 ops/sec [173,088..205,298]	~ overlap (-1.9%)	233,971 ops/sec [224,941..255,910] → 269,169 ops/sec [238,213..293,966]	~ overlap (+15.0%)
clone ArrayBuffer(64)	134,104 ops/sec [133,833..135,191] → 132,930 ops/sec [132,117..133,526]	🔴 -0.9%	170,552 ops/sec [160,961..189,071] → 168,396 ops/sec [167,802..197,774]	~ overlap (-1.3%)
clone ArrayBuffer(1024)	123,341 ops/sec [121,905..123,529] → 121,038 ops/sec [119,674..121,694]	🔴 -1.9%	145,089 ops/sec [142,789..146,838] → 144,004 ops/sec [143,489..144,488]	~ overlap (-0.7%)
clone ArrayBuffer inside object	88,046 ops/sec [87,645..91,301] → 88,841 ops/sec [88,042..103,689]	~ overlap (+0.9%)	103,067 ops/sec [99,127..109,334] → 101,522 ops/sec [101,261..102,137]	~ overlap (-1.5%)

arrays.js — Interp: 🟢 1, 18 unch. · avg +0.3% · Bytecode: 🟢 1, 🔴 1, 17 unch. · avg +0.6%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Array.from length 100	3,469 ops/sec [3,337..4,766] → 3,466 ops/sec [3,408..3,491]	~ overlap (-0.1%)	3,067 ops/sec [2,856..3,100] → 3,457 ops/sec [3,052..3,682]	~ overlap (+12.7%)
Array.from 10 elements	68,996 ops/sec [66,934..79,723] → 69,880 ops/sec [67,173..76,141]	~ overlap (+1.3%)	74,716 ops/sec [74,016..75,572] → 74,009 ops/sec [73,618..80,963]	~ overlap (-0.9%)
Array.of 10 elements	85,988 ops/sec [85,245..87,889] → 89,102 ops/sec [85,607..105,052]	~ overlap (+3.6%)	106,363 ops/sec [97,710..109,329] → 106,809 ops/sec [105,121..107,873]	~ overlap (+0.4%)
spread into new array	103,099 ops/sec [98,171..111,672] → 98,402 ops/sec [98,152..98,467]	~ overlap (-4.6%)	54,363 ops/sec [53,187..57,266] → 53,703 ops/sec [53,040..54,009]	~ overlap (-1.2%)
map over 50 elements	5,377 ops/sec [5,346..5,390] → 5,498 ops/sec [5,466..5,810]	🟢 +2.2%	5,820 ops/sec [5,509..5,833] → 5,826 ops/sec [5,598..6,060]	~ overlap (+0.1%)
filter over 50 elements	5,006 ops/sec [4,582..5,189] → 5,100 ops/sec [5,063..5,132]	~ overlap (+1.9%)	5,692 ops/sec [5,636..5,787] → 5,570 ops/sec [5,533..5,686]	~ overlap (-2.1%)
reduce sum 50 elements	5,408 ops/sec [5,370..7,106] → 5,606 ops/sec [5,535..5,652]	~ overlap (+3.7%)	5,539 ops/sec [5,071..5,755] → 5,544 ops/sec [5,474..5,569]	~ overlap (+0.1%)
forEach over 50 elements	3,812 ops/sec [3,746..4,288] → 3,861 ops/sec [3,804..3,887]	~ overlap (+1.3%)	6,273 ops/sec [5,918..6,765] → 5,843 ops/sec [5,549..6,445]	~ overlap (-6.9%)
find in 50 elements	7,212 ops/sec [7,142..8,107] → 7,299 ops/sec [7,238..7,331]	~ overlap (+1.2%)	7,872 ops/sec [7,728..8,247] → 7,705 ops/sec [7,684..7,716]	🔴 -2.1%
sort 20 elements	4,607 ops/sec [4,547..4,855] → 4,623 ops/sec [4,528..4,629]	~ overlap (+0.4%)	5,053 ops/sec [5,005..5,062] → 5,029 ops/sec [4,999..5,046]	~ overlap (-0.5%)
flat nested array	42,214 ops/sec [41,548..44,061] → 42,334 ops/sec [42,130..42,558]	~ overlap (+0.3%)	45,347 ops/sec [45,189..45,535] → 44,867 ops/sec [43,611..51,088]	~ overlap (-1.1%)
flatMap	23,025 ops/sec [22,505..25,606] → 24,725 ops/sec [23,066..27,599]	~ overlap (+7.4%)	24,128 ops/sec [24,047..24,310] → 23,736 ops/sec [23,575..24,130]	~ overlap (-1.6%)
map inside map (5x5)	5,945 ops/sec [5,914..5,962] → 6,013 ops/sec [5,925..6,027]	~ overlap (+1.1%)	6,276 ops/sec [6,006..6,325] → 6,240 ops/sec [6,203..6,284]	~ overlap (-0.6%)
filter inside map (5x10)	3,933 ops/sec [3,899..4,478] → 4,016 ops/sec [3,944..4,099]	~ overlap (+2.1%)	4,385 ops/sec [4,339..4,461] → 4,471 ops/sec [4,352..4,616]	~ overlap (+2.0%)
reduce inside map (5x10)	4,436 ops/sec [4,368..4,517] → 4,503 ops/sec [4,480..4,542]	~ overlap (+1.5%)	4,625 ops/sec [4,500..5,283] → 4,704 ops/sec [4,619..5,000]	~ overlap (+1.7%)
forEach inside forEach (5x10)	3,320 ops/sec [3,203..3,583] → 3,214 ops/sec [3,156..3,256]	~ overlap (-3.2%)	4,896 ops/sec [4,680..4,979] → 4,984 ops/sec [4,893..5,567]	~ overlap (+1.8%)
find inside some (10x10)	3,284 ops/sec [3,266..3,306] → 3,341 ops/sec [3,284..3,358]	~ overlap (+1.7%)	3,368 ops/sec [3,354..3,602] → 3,539 ops/sec [3,523..3,547]	~ overlap (+5.1%)
map+filter chain nested (5x20)	1,316 ops/sec [1,210..1,668] → 1,235 ops/sec [1,228..1,410]	~ overlap (-6.2%)	1,364 ops/sec [1,335..1,532] → 1,366 ops/sec [1,310..1,422]	~ overlap (+0.2%)
reduce flatten (10x5)	11,643 ops/sec [10,278..12,198] → 10,432 ops/sec [10,367..10,555]	~ overlap (-10.4%)	4,222 ops/sec [4,202..4,236] → 4,408 ops/sec [4,283..4,519]	🟢 +4.4%

async-await.js — Interp: 6 unch. · avg -4.6% · Bytecode: 🟢 2, 4 unch. · avg +6.7%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
single await	28,094 ops/sec [24,120..31,098] → 24,429 ops/sec [23,981..24,713]	~ overlap (-13.0%)	24,134 ops/sec [23,508..25,109] → 23,351 ops/sec [20,004..23,765]	~ overlap (-3.2%)
multiple awaits	11,793 ops/sec [9,849..12,297] → 9,879 ops/sec [9,816..9,922]	~ overlap (-16.2%)	8,584 ops/sec [7,556..10,073] → 9,516 ops/sec [8,389..10,330]	~ overlap (+10.9%)
await non-Promise value	34,034 ops/sec [33,063..38,104] → 33,714 ops/sec [31,795..38,512]	~ overlap (-0.9%)	30,090 ops/sec [23,682..30,683] → 31,875 ops/sec [31,355..35,672]	🟢 +5.9%
await with try/catch	20,765 ops/sec [20,160..20,976] → 21,190 ops/sec [20,942..21,215]	~ overlap (+2.0%)	21,902 ops/sec [19,942..23,776] → 22,517 ops/sec [22,229..22,968]	~ overlap (+2.8%)
await Promise.all	5,688 ops/sec [5,647..5,729] → 5,729 ops/sec [5,704..5,755]	~ overlap (+0.7%)	5,335 ops/sec [4,982..5,924] → 5,581 ops/sec [5,518..5,719]	~ overlap (+4.6%)
nested async function call	13,910 ops/sec [13,657..14,855] → 13,868 ops/sec [13,394..14,078]	~ overlap (-0.3%)	11,526 ops/sec [11,162..12,378] → 13,766 ops/sec [12,771..13,999]	🟢 +19.4%

async-generators.js — Interp: 2 unch. · avg +9.1% · Bytecode: 2 unch. · avg +2.5%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for-await-of over async generator	1,630 ops/sec [1,581..1,952] → 1,630 ops/sec [1,496..1,832]	~ overlap (-0.0%)	599 ops/sec [579..623] → 587 ops/sec [538..595]	~ overlap (-2.0%)
async generator with await in body	10,909 ops/sec [10,823..12,831] → 12,901 ops/sec [11,015..14,381]	~ overlap (+18.3%)	4,447 ops/sec [4,414..4,550] → 4,760 ops/sec [4,227..4,853]	~ overlap (+7.0%)

atomics.js — Interp: 🟢 1, 5 unch. · avg +0.9% · Bytecode: 🟢 2, 4 unch. · avg +6.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
load and store Int32Array	86,783 ops/sec [81,644..88,846] → 83,385 ops/sec [82,719..85,214]	~ overlap (-3.9%)	121,121 ops/sec [111,141..123,422] → 123,984 ops/sec [122,599..139,660]	~ overlap (+2.4%)
read-modify-write Int32Array	57,677 ops/sec [55,683..60,886] → 56,387 ops/sec [55,802..56,505]	~ overlap (-2.2%)	78,130 ops/sec [75,839..79,265] → 96,481 ops/sec [80,513..101,323]	🟢 +23.5%
compareExchange hit and miss	50,402 ops/sec [50,044..50,439] → 55,835 ops/sec [51,149..60,048]	🟢 +10.8%	68,983 ops/sec [67,771..79,335] → 74,200 ops/sec [73,835..74,463]	~ overlap (+7.6%)
wait with zero timeout	131,707 ops/sec [101,159..147,769] → 133,234 ops/sec [131,766..133,750]	~ overlap (+1.2%)	188,058 ops/sec [182,435..188,542] → 197,943 ops/sec [189,214..203,336]	🟢 +5.3%
waitAsync synchronous not-equal	97,392 ops/sec [95,788..111,539] → 96,951 ops/sec [96,592..97,153]	~ overlap (-0.5%)	120,347 ops/sec [119,049..135,894] → 122,983 ops/sec [108,853..129,987]	~ overlap (+2.2%)
notify with no waiters	141,784 ops/sec [140,459..151,924] → 141,626 ops/sec [139,743..141,901]	~ overlap (-0.1%)	198,490 ops/sec [180,578..210,082] → 189,305 ops/sec [188,600..190,184]	~ overlap (-4.6%)

base64.js — Interp: 🟢 2, 8 unch. · avg +0.3% · Bytecode: 10 unch. · avg -1.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
short ASCII (13 chars)	2,487 ops/sec [2,457..2,497] → 2,527 ops/sec [2,499..2,536]	🟢 +1.6%	2,455 ops/sec [2,418..2,484] → 2,454 ops/sec [2,446..2,472]	~ overlap (-0.0%)
medium ASCII (450 chars)	90 ops/sec [89..111] → 91 ops/sec [91..100]	~ overlap (+1.3%)	89 ops/sec [87..89] → 88 ops/sec [87..89]	~ overlap (-0.9%)
Latin-1 characters	3,671 ops/sec [3,642..3,693] → 3,649 ops/sec [3,619..3,840]	~ overlap (-0.6%)	3,507 ops/sec [3,495..3,520] → 3,486 ops/sec [3,476..3,496]	~ overlap (-0.6%)
short base64 (20 chars)	1,818 ops/sec [1,815..1,820] → 1,813 ops/sec [1,789..1,827]	~ overlap (-0.3%)	1,734 ops/sec [1,721..1,739] → 1,736 ops/sec [1,723..1,757]	~ overlap (+0.1%)
medium base64 (600 chars)	71 ops/sec [70..74] → 70 ops/sec [67..73]	~ overlap (-1.6%)	73 ops/sec [68..83] → 68 ops/sec [67..69]	~ overlap (-7.7%)
Latin-1 output	2,602 ops/sec [2,562..2,642] → 2,607 ops/sec [2,593..2,620]	~ overlap (+0.2%)	2,469 ops/sec [2,424..2,489] → 2,493 ops/sec [2,428..3,062]	~ overlap (+1.0%)
forgiving (no padding)	3,898 ops/sec [3,877..3,918] → 3,959 ops/sec [3,932..4,096]	🟢 +1.6%	3,712 ops/sec [3,658..3,921] → 3,733 ops/sec [3,616..3,783]	~ overlap (+0.6%)
with whitespace	1,832 ops/sec [1,695..1,913] → 1,721 ops/sec [1,697..2,151]	~ overlap (-6.0%)	1,589 ops/sec [1,585..1,596] → 1,612 ops/sec [1,593..1,640]	~ overlap (+1.4%)
atob(btoa(short))	1,060 ops/sec [1,052..1,279] → 1,064 ops/sec [1,042..1,116]	~ overlap (+0.3%)	1,018 ops/sec [1,012..1,141] → 1,031 ops/sec [1,022..1,035]	~ overlap (+1.3%)
atob(btoa(medium))	42 ops/sec [39..42] → 45 ops/sec [40..47]	~ overlap (+7.1%)	41 ops/sec [39..45] → 39 ops/sec [38..42]	~ overlap (-6.8%)

classes.js — Interp: 🔴 5, 26 unch. · avg -0.4% · Bytecode: 🟢 3, 28 unch. · avg +0.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple class new	42,039 ops/sec [41,876..42,414] → 41,184 ops/sec [40,818..41,493]	🔴 -2.0%	52,725 ops/sec [52,192..52,961] → 52,134 ops/sec [51,121..52,624]	~ overlap (-1.1%)
class with defaults	32,442 ops/sec [31,661..36,507] → 32,449 ops/sec [32,030..35,884]	~ overlap (+0.0%)	35,610 ops/sec [34,124..37,495] → 36,261 ops/sec [35,756..36,449]	~ overlap (+1.8%)
50 instances via Array.from	1,470 ops/sec [1,452..1,674] → 1,511 ops/sec [1,369..1,719]	~ overlap (+2.8%)	1,623 ops/sec [1,594..1,638] → 1,655 ops/sec [1,652..1,681]	🟢 +2.0%
instance method call	19,249 ops/sec [19,218..19,388] → 19,243 ops/sec [19,154..21,091]	~ overlap (-0.0%)	27,216 ops/sec [26,265..27,815] → 27,761 ops/sec [27,559..28,384]	~ overlap (+2.0%)
static method call	33,223 ops/sec [32,907..33,312] → 33,386 ops/sec [32,915..39,874]	~ overlap (+0.5%)	55,510 ops/sec [54,656..56,646] → 57,278 ops/sec [56,974..57,706]	🟢 +3.2%
single-level inheritance	18,430 ops/sec [16,622..19,478] → 17,482 ops/sec [16,846..17,552]	~ overlap (-5.1%)	19,822 ops/sec [19,319..22,078] → 19,900 ops/sec [19,503..20,991]	~ overlap (+0.4%)
two-level inheritance	16,203 ops/sec [14,722..17,722] → 14,853 ops/sec [14,459..17,730]	~ overlap (-8.3%)	15,174 ops/sec [15,027..16,366] → 15,020 ops/sec [14,988..15,151]	~ overlap (-1.0%)
private field access	20,833 ops/sec [20,683..23,192] → 20,875 ops/sec [20,323..21,078]	~ overlap (+0.2%)	14,729 ops/sec [14,480..15,140] → 14,755 ops/sec [14,727..15,691]	~ overlap (+0.2%)
private methods	23,681 ops/sec [23,219..23,909] → 23,683 ops/sec [23,052..27,834]	~ overlap (+0.0%)	16,184 ops/sec [15,849..16,362] → 16,599 ops/sec [16,420..17,065]	🟢 +2.6%
getter/setter access	22,675 ops/sec [22,407..24,646] → 22,612 ops/sec [22,461..22,830]	~ overlap (-0.3%)	29,287 ops/sec [29,151..29,519] → 29,508 ops/sec [29,211..29,625]	~ overlap (+0.8%)
class decorator (identity)	35,820 ops/sec [33,543..42,218] → 34,180 ops/sec [33,746..37,519]	~ overlap (-4.6%)	33,727 ops/sec [33,513..37,568] → 32,742 ops/sec [32,131..35,918]	~ overlap (-2.9%)
class decorator (wrapping)	18,759 ops/sec [18,466..18,882] → 18,413 ops/sec [18,006..18,522]	~ overlap (-1.8%)	19,290 ops/sec [17,428..22,518] → 17,433 ops/sec [17,271..17,756]	~ overlap (-9.6%)
identity method decorator	23,823 ops/sec [23,652..24,213] → 27,715 ops/sec [23,754..30,672]	~ overlap (+16.3%)	27,690 ops/sec [27,095..30,426] → 27,641 ops/sec [27,474..27,827]	~ overlap (-0.2%)
wrapping method decorator	19,390 ops/sec [18,849..26,779] → 20,439 ops/sec [18,932..23,001]	~ overlap (+5.4%)	20,310 ops/sec [19,861..21,050] → 20,977 ops/sec [20,751..27,461]	~ overlap (+3.3%)
stacked method decorators (x3)	13,895 ops/sec [13,005..16,277] → 13,978 ops/sec [13,564..17,110]	~ overlap (+0.6%)	15,265 ops/sec [14,961..20,791] → 16,932 ops/sec [15,347..18,162]	~ overlap (+10.9%)
identity field decorator	26,956 ops/sec [26,427..31,818] → 26,680 ops/sec [26,306..27,905]	~ overlap (-1.0%)	29,330 ops/sec [26,969..31,856] → 29,996 ops/sec [28,927..36,175]	~ overlap (+2.3%)
field initializer decorator	22,922 ops/sec [22,824..22,950] → 22,402 ops/sec [21,715..22,675]	🔴 -2.3%	23,594 ops/sec [23,111..23,934] → 23,587 ops/sec [23,277..32,881]	~ overlap (-0.0%)
getter decorator (identity)	22,443 ops/sec [21,456..24,913] → 21,128 ops/sec [20,961..21,432]	🔴 -5.9%	18,462 ops/sec [18,016..18,605] → 18,551 ops/sec [18,494..18,634]	~ overlap (+0.5%)
setter decorator (identity)	18,084 ops/sec [16,986..19,664] → 17,686 ops/sec [17,271..17,915]	~ overlap (-2.2%)	15,320 ops/sec [14,667..15,577] → 16,749 ops/sec [14,959..17,565]	~ overlap (+9.3%)
static method decorator	24,819 ops/sec [24,338..25,260] → 25,137 ops/sec [24,619..27,989]	~ overlap (+1.3%)	31,472 ops/sec [30,986..33,793] → 31,402 ops/sec [31,047..32,893]	~ overlap (-0.2%)
static field decorator	29,957 ops/sec [29,237..44,286] → 30,112 ops/sec [29,684..30,293]	~ overlap (+0.5%)	40,649 ops/sec [33,341..40,859] → 36,318 ops/sec [33,641..44,860]	~ overlap (-10.7%)
private method decorator	18,326 ops/sec [18,172..23,028] → 19,322 ops/sec [18,049..20,295]	~ overlap (+5.4%)	19,961 ops/sec [19,688..20,382] → 20,183 ops/sec [19,770..20,361]	~ overlap (+1.1%)
private field decorator	21,487 ops/sec [20,774..24,955] → 20,584 ops/sec [20,319..20,677]	🔴 -4.2%	19,235 ops/sec [18,236..21,918] → 18,371 ops/sec [18,319..18,639]	~ overlap (-4.5%)
plain auto-accessor (no decorator)	36,211 ops/sec [35,386..36,974] → 34,537 ops/sec [34,043..34,928]	🔴 -4.6%	33,261 ops/sec [32,715..33,821] → 34,185 ops/sec [33,247..36,076]	~ overlap (+2.8%)
auto-accessor with decorator	20,669 ops/sec [20,277..20,734] → 20,381 ops/sec [20,008..21,661]	~ overlap (-1.4%)	20,617 ops/sec [20,055..24,207] → 20,040 ops/sec [19,103..20,520]	~ overlap (-2.8%)
decorator writing metadata	16,706 ops/sec [16,553..16,812] → 16,625 ops/sec [16,376..17,015]	~ overlap (-0.5%)	18,987 ops/sec [18,916..19,128] → 18,798 ops/sec [18,383..21,971]	~ overlap (-1.0%)
static getter read	42,874 ops/sec [39,366..45,971] → 38,913 ops/sec [38,490..56,296]	~ overlap (-9.2%)	53,260 ops/sec [52,733..53,338] → 52,651 ops/sec [52,227..53,382]	~ overlap (-1.1%)
static getter/setter pair	27,373 ops/sec [27,085..31,924] → 27,876 ops/sec [27,702..30,941]	~ overlap (+1.8%)	44,274 ops/sec [37,999..51,021] → 39,744 ops/sec [38,507..42,201]	~ overlap (-10.2%)
inherited static getter	24,647 ops/sec [24,528..26,430] → 26,295 ops/sec [25,813..26,352]	~ overlap (+6.7%)	36,011 ops/sec [34,248..38,660] → 38,334 ops/sec [33,329..48,163]	~ overlap (+6.4%)
inherited static setter	25,759 ops/sec [25,489..26,181] → 25,651 ops/sec [25,386..25,994]	~ overlap (-0.4%)	35,960 ops/sec [33,710..43,435] → 34,203 ops/sec [33,456..40,184]	~ overlap (-4.9%)
inherited static getter with this binding	19,800 ops/sec [19,614..19,905] → 19,765 ops/sec [19,366..19,932]	~ overlap (-0.2%)	26,549 ops/sec [26,305..27,290] → 26,783 ops/sec [26,678..28,833]	~ overlap (+0.9%)

closures.js — Interp: 🟢 2, 🔴 2, 7 unch. · avg +1.6% · Bytecode: 11 unch. · avg -1.7%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
closure over single variable	29,333 ops/sec [29,218..41,798] → 28,806 ops/sec [28,532..29,202]	🔴 -1.8%	92,068 ops/sec [90,216..93,671] → 94,681 ops/sec [93,336..95,043]	~ overlap (+2.8%)
closure over multiple variables	36,970 ops/sec [35,853..42,157] → 37,308 ops/sec [35,728..40,313]	~ overlap (+0.9%)	87,410 ops/sec [86,044..89,516] → 85,552 ops/sec [83,870..86,153]	~ overlap (-2.1%)
nested closures	38,899 ops/sec [38,715..39,019] → 38,548 ops/sec [37,998..52,831]	~ overlap (-0.9%)	86,081 ops/sec [81,542..97,803] → 85,818 ops/sec [85,497..86,529]	~ overlap (-0.3%)
function as argument	28,996 ops/sec [28,840..29,135] → 29,589 ops/sec [29,203..29,985]	🟢 +2.0%	81,742 ops/sec [80,834..84,570] → 81,835 ops/sec [81,338..82,123]	~ overlap (+0.1%)
function returning function	36,983 ops/sec [36,140..43,659] → 37,421 ops/sec [37,238..37,651]	~ overlap (+1.2%)	94,067 ops/sec [92,859..95,562] → 93,570 ops/sec [93,073..115,995]	~ overlap (-0.5%)
compose two functions	23,424 ops/sec [23,140..26,375] → 27,930 ops/sec [23,600..28,730]	~ overlap (+19.2%)	56,329 ops/sec [48,712..57,167] → 56,835 ops/sec [56,671..56,927]	~ overlap (+0.9%)
fn.call	56,537 ops/sec [51,358..58,787] → 50,292 ops/sec [49,951..51,337]	🔴 -11.0%	76,528 ops/sec [70,488..95,706] → 71,551 ops/sec [70,203..73,242]	~ overlap (-6.5%)
fn.apply	39,927 ops/sec [39,329..47,203] → 39,824 ops/sec [38,783..44,769]	~ overlap (-0.3%)	70,252 ops/sec [69,539..70,842] → 69,245 ops/sec [68,607..69,621]	~ overlap (-1.4%)
fn.bind	43,245 ops/sec [42,563..43,973] → 43,216 ops/sec [42,955..44,252]	~ overlap (-0.1%)	90,837 ops/sec [89,718..95,071] → 92,485 ops/sec [91,337..93,112]	~ overlap (+1.8%)
recursive sum to 50	3,462 ops/sec [3,455..3,468] → 3,578 ops/sec [3,540..3,617]	🟢 +3.4%	13,469 ops/sec [12,374..14,546] → 11,675 ops/sec [11,474..13,758]	~ overlap (-13.3%)
recursive tree traversal	5,179 ops/sec [5,146..5,221] → 5,444 ops/sec [5,187..6,176]	~ overlap (+5.1%)	11,587 ops/sec [11,129..12,255] → 11,530 ops/sec [11,408..14,783]	~ overlap (-0.5%)

collections.js — Interp: 🟢 2, 10 unch. · avg +0.1% · Bytecode: 12 unch. · avg -0.7%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
add 50 elements	3,035 ops/sec [2,983..3,221] → 3,123 ops/sec [2,934..3,287]	~ overlap (+2.9%)	4,171 ops/sec [3,726..4,348] → 3,816 ops/sec [3,757..3,826]	~ overlap (-8.5%)
has lookup (50 elements)	63,711 ops/sec [63,599..63,901] → 63,775 ops/sec [63,585..64,596]	~ overlap (+0.1%)	94,400 ops/sec [93,097..111,835] → 96,251 ops/sec [95,897..103,032]	~ overlap (+2.0%)
delete elements	35,025 ops/sec [34,944..35,558] → 36,329 ops/sec [35,885..38,249]	🟢 +3.7%	47,347 ops/sec [45,922..48,975] → 49,535 ops/sec [45,898..51,656]	~ overlap (+4.6%)
forEach iteration	4,007 ops/sec [4,000..4,021] → 4,060 ops/sec [4,039..4,080]	🟢 +1.3%	6,234 ops/sec [6,070..7,272] → 6,161 ops/sec [6,128..8,241]	~ overlap (-1.2%)
spread to array	14,254 ops/sec [12,147..19,613] → 12,063 ops/sec [11,707..12,300]	~ overlap (-15.4%)	74,826 ops/sec [71,680..88,506] → 80,277 ops/sec [78,964..81,611]	~ overlap (+7.3%)
deduplicate array	22,215 ops/sec [20,101..25,058] → 22,752 ops/sec [22,167..22,843]	~ overlap (+2.4%)	46,003 ops/sec [40,121..47,502] → 45,620 ops/sec [39,630..50,286]	~ overlap (-0.8%)
set 50 entries	2,372 ops/sec [2,256..2,501] → 2,281 ops/sec [2,250..2,297]	~ overlap (-3.8%)	2,873 ops/sec [2,848..3,898] → 3,357 ops/sec [2,956..3,667]	~ overlap (+16.9%)
get lookup (50 entries)	67,017 ops/sec [66,464..69,474] → 64,185 ops/sec [63,353..68,143]	~ overlap (-4.2%)	86,828 ops/sec [80,631..88,034] → 86,430 ops/sec [85,468..87,849]	~ overlap (-0.5%)
has check	84,022 ops/sec [82,010..87,895] → 96,013 ops/sec [85,266..103,004]	~ overlap (+14.3%)	111,284 ops/sec [108,372..115,350] → 111,334 ops/sec [109,554..113,707]	~ overlap (+0.0%)
delete entries	34,839 ops/sec [34,190..35,170] → 37,139 ops/sec [34,532..43,101]	~ overlap (+6.6%)	43,360 ops/sec [42,906..45,393] → 44,289 ops/sec [43,691..45,354]	~ overlap (+2.1%)
forEach iteration	4,111 ops/sec [3,957..4,271] → 3,990 ops/sec [3,962..4,019]	~ overlap (-2.9%)	6,927 ops/sec [6,430..7,844] → 6,415 ops/sec [6,357..6,574]	~ overlap (-7.4%)
keys/values/entries	3,596 ops/sec [3,497..5,471] → 3,456 ops/sec [3,388..5,419]	~ overlap (-3.9%)	14,961 ops/sec [12,744..16,850] → 11,524 ops/sec [11,145..13,903]	~ overlap (-23.0%)

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

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple 3-column CSV	40,673 ops/sec [40,331..60,525] → 41,323 ops/sec [40,209..52,950]	~ overlap (+1.6%)	45,686 ops/sec [39,401..49,186] → 43,510 ops/sec [42,505..53,331]	~ overlap (-4.8%)
parse 10-row CSV	11,511 ops/sec [11,406..12,791] → 11,466 ops/sec [11,413..11,761]	~ overlap (-0.4%)	11,748 ops/sec [11,099..12,721] → 11,910 ops/sec [11,855..12,134]	~ overlap (+1.4%)
parse 100-row CSV	2,063 ops/sec [1,846..2,304] → 1,850 ops/sec [1,777..1,855]	~ overlap (-10.3%)	1,870 ops/sec [1,837..2,080] → 1,899 ops/sec [1,860..2,235]	~ overlap (+1.5%)
parse CSV with quoted fields	58,641 ops/sec [58,489..59,306] → 59,604 ops/sec [58,579..59,670]	~ overlap (+1.6%)	63,790 ops/sec [63,416..72,577] → 67,368 ops/sec [62,565..72,920]	~ overlap (+5.6%)
parse without headers (array of arrays)	5,486 ops/sec [5,375..7,978] → 5,427 ops/sec [5,267..6,260]	~ overlap (-1.1%)	5,645 ops/sec [5,622..7,051] → 5,477 ops/sec [5,363..6,626]	~ overlap (-3.0%)
parse with semicolon delimiter	9,821 ops/sec [8,993..10,890] → 8,683 ops/sec [8,575..8,761]	🔴 -11.6%	8,575 ops/sec [8,365..10,120] → 9,032 ops/sec [8,409..11,246]	~ overlap (+5.3%)
stringify array of objects	53,505 ops/sec [53,016..64,320] → 53,317 ops/sec [52,934..94,232]	~ overlap (-0.4%)	63,405 ops/sec [63,358..64,285] → 65,803 ops/sec [63,139..67,398]	~ overlap (+3.8%)
stringify array of arrays	23,992 ops/sec [21,958..25,650] → 21,881 ops/sec [21,822..22,052]	~ overlap (-8.8%)	23,302 ops/sec [23,192..23,514] → 23,613 ops/sec [23,472..23,751]	~ overlap (+1.3%)
stringify with values needing escaping	43,047 ops/sec [42,849..45,412] → 44,569 ops/sec [43,314..49,812]	~ overlap (+3.5%)	50,959 ops/sec [48,341..52,621] → 48,718 ops/sec [46,767..50,425]	~ overlap (-4.4%)
reviver converts numbers	906 ops/sec [866..1,086] → 903 ops/sec [895..908]	~ overlap (-0.4%)	1,213 ops/sec [1,084..1,489] → 1,111 ops/sec [1,052..1,115]	~ overlap (-8.4%)
reviver filters empty to null	7,933 ops/sec [7,240..9,276] → 7,582 ops/sec [7,513..7,676]	~ overlap (-4.4%)	10,257 ops/sec [10,220..10,328] → 10,252 ops/sec [10,181..10,306]	~ overlap (-0.0%)
parse then stringify	8,156 ops/sec [7,305..8,755] → 7,439 ops/sec [7,374..10,792]	~ overlap (-8.8%)	8,545 ops/sec [7,811..9,028] → 7,753 ops/sec [7,528..7,836]	~ overlap (-9.3%)
stringify then parse	7,132 ops/sec [7,093..8,150] → 7,836 ops/sec [7,199..8,687]	~ overlap (+9.9%)	7,723 ops/sec [7,621..7,775] → 7,739 ops/sec [7,530..7,913]	~ overlap (+0.2%)

destructuring.js — Interp: 🟢 2, 🔴 2, 18 unch. · avg +0.8% · Bytecode: 🟢 1, 21 unch. · avg +0.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple array destructuring	65,066 ops/sec [64,280..66,249] → 66,999 ops/sec [65,640..68,203]	~ overlap (+3.0%)	84,022 ops/sec [81,443..85,127] → 83,102 ops/sec [79,850..83,333]	~ overlap (-1.1%)
with rest element	54,497 ops/sec [54,213..60,638] → 57,479 ops/sec [56,548..61,523]	~ overlap (+5.5%)	69,055 ops/sec [64,409..94,953] → 65,481 ops/sec [64,714..68,195]	~ overlap (-5.2%)
with defaults	68,859 ops/sec [66,930..84,966] → 70,288 ops/sec [69,469..74,341]	~ overlap (+2.1%)	89,905 ops/sec [87,016..128,946] → 88,435 ops/sec [82,998..101,836]	~ overlap (-1.6%)
skip elements	76,772 ops/sec [74,485..80,611] → 77,715 ops/sec [73,808..81,984]	~ overlap (+1.2%)	91,164 ops/sec [88,855..92,063] → 90,502 ops/sec [88,842..104,940]	~ overlap (-0.7%)
nested array destructuring	33,090 ops/sec [31,093..40,122] → 32,131 ops/sec [31,861..32,195]	~ overlap (-2.9%)	31,804 ops/sec [30,847..32,789] → 31,884 ops/sec [31,608..32,128]	~ overlap (+0.3%)
swap variables	93,296 ops/sec [92,465..103,297] → 93,516 ops/sec [92,881..94,450]	~ overlap (+0.2%)	122,112 ops/sec [120,562..123,156] → 130,557 ops/sec [120,685..132,480]	~ overlap (+6.9%)
simple object destructuring	81,445 ops/sec [79,143..117,284] → 86,470 ops/sec [79,559..97,496]	~ overlap (+6.2%)	96,047 ops/sec [95,700..113,691] → 94,293 ops/sec [89,876..101,282]	~ overlap (-1.8%)
with defaults	91,872 ops/sec [89,801..109,771] → 88,742 ops/sec [88,547..90,878]	~ overlap (-3.4%)	138,444 ops/sec [133,223..163,855] → 136,397 ops/sec [133,361..138,117]	~ overlap (-1.5%)
with renaming	93,042 ops/sec [91,785..99,452] → 95,537 ops/sec [87,671..110,905]	~ overlap (+2.7%)	101,209 ops/sec [100,964..101,566] → 101,191 ops/sec [100,057..101,753]	~ overlap (-0.0%)
nested object destructuring	51,686 ops/sec [49,496..51,816] → 49,235 ops/sec [48,916..50,016]	~ overlap (-4.7%)	51,423 ops/sec [51,240..51,783] → 51,056 ops/sec [50,716..51,300]	~ overlap (-0.7%)
rest properties	37,582 ops/sec [37,099..37,821] → 36,093 ops/sec [35,956..36,256]	🔴 -4.0%	43,756 ops/sec [43,325..44,978] → 43,742 ops/sec [42,939..46,641]	~ overlap (-0.0%)
object parameter	27,630 ops/sec [27,104..32,964] → 26,581 ops/sec [26,361..26,764]	🔴 -3.8%	42,534 ops/sec [42,380..42,706] → 42,172 ops/sec [42,070..44,680]	~ overlap (-0.9%)
array parameter	32,314 ops/sec [32,038..32,466] → 32,375 ops/sec [32,142..32,452]	~ overlap (+0.2%)	43,402 ops/sec [42,731..44,959] → 47,650 ops/sec [42,198..53,682]	~ overlap (+9.8%)
mixed destructuring in map	8,677 ops/sec [8,091..8,710] → 8,731 ops/sec [8,533..8,869]	~ overlap (+0.6%)	11,068 ops/sec [10,876..11,122] → 11,272 ops/sec [11,108..11,646]	~ overlap (+1.8%)
forEach with array destructuring	14,378 ops/sec [14,261..16,194] → 14,232 ops/sec [14,094..14,435]	~ overlap (-1.0%)	16,105 ops/sec [15,746..16,805] → 15,346 ops/sec [14,822..15,846]	~ overlap (-4.7%)
map with array destructuring	16,938 ops/sec [16,734..17,037] → 16,702 ops/sec [16,622..16,857]	~ overlap (-1.4%)	15,362 ops/sec [15,141..15,432] → 15,436 ops/sec [14,624..16,057]	~ overlap (+0.5%)
filter with array destructuring	17,788 ops/sec [17,742..17,902] → 17,755 ops/sec [16,887..21,845]	~ overlap (-0.2%)	17,394 ops/sec [16,093..19,671] → 17,161 ops/sec [15,882..17,453]	~ overlap (-1.3%)
reduce with array destructuring	17,681 ops/sec [17,503..18,115] → 18,042 ops/sec [17,919..24,061]	~ overlap (+2.0%)	18,077 ops/sec [16,576..19,604] → 16,387 ops/sec [16,363..17,403]	~ overlap (-9.3%)
map with object destructuring	19,702 ops/sec [19,394..21,929] → 20,652 ops/sec [19,734..29,479]	~ overlap (+4.8%)	24,623 ops/sec [22,539..25,511] → 23,415 ops/sec [23,358..23,478]	~ overlap (-4.9%)
map with nested destructuring	15,616 ops/sec [15,432..15,663] → 16,189 ops/sec [16,053..16,376]	🟢 +3.7%	23,110 ops/sec [23,097..23,253] → 23,215 ops/sec [22,625..23,399]	~ overlap (+0.5%)
map with rest in destructuring	9,000 ops/sec [8,841..9,112] → 9,289 ops/sec [9,209..9,332]	🟢 +3.2%	7,920 ops/sec [7,668..7,978] → 8,734 ops/sec [7,965..9,002]	~ overlap (+10.3%)
map with defaults in destructuring	10,703 ops/sec [10,479..10,968] → 11,070 ops/sec [10,955..11,214]	~ overlap (+3.4%)	17,628 ops/sec [17,393..17,750] → 18,593 ops/sec [18,589..18,630]	🟢 +5.5%

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

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
recursive fib(15)	99 ops/sec [98..102] → 101 ops/sec [97..113]	~ overlap (+1.8%)	320 ops/sec [318..512] → 320 ops/sec [315..351]	~ overlap (-0.0%)
recursive fib(20)	10 ops/sec [9..10] → 9 ops/sec [9..10]	~ overlap (-5.8%)	31 ops/sec [29..33] → 29 ops/sec [29..30]	~ overlap (-6.0%)
recursive fib(15) typed	95 ops/sec [94..102] → 95 ops/sec [94..96]	~ overlap (+0.1%)	348 ops/sec [321..378] → 361 ops/sec [325..395]	~ overlap (+3.9%)
recursive fib(20) typed	9 ops/sec [9..10] → 9 ops/sec [9..10]	~ overlap (+3.6%)	29 ops/sec [29..30] → 30 ops/sec [29..36]	~ overlap (+5.4%)
iterative fib(20) via reduce	4,372 ops/sec [4,202..5,231] → 4,190 ops/sec [4,175..4,455]	~ overlap (-4.2%)	6,581 ops/sec [4,614..7,908] → 6,766 ops/sec [6,640..8,249]	~ overlap (+2.8%)
iterator fib(20)	2,347 ops/sec [2,320..2,802] → 2,375 ops/sec [2,329..2,387]	~ overlap (+1.2%)	5,367 ops/sec [4,939..5,886] → 4,877 ops/sec [4,690..4,922]	🔴 -9.1%
iterator fib(20) via Iterator.from + take	2,243 ops/sec [2,180..2,402] → 2,334 ops/sec [2,200..2,356]	~ overlap (+4.1%)	2,763 ops/sec [2,744..2,790] → 2,687 ops/sec [2,642..2,775]	~ overlap (-2.8%)
iterator fib(20) last value via reduce	2,101 ops/sec [1,929..2,255] → 2,056 ops/sec [2,036..2,338]	~ overlap (-2.1%)	2,331 ops/sec [2,287..2,622] → 2,298 ops/sec [2,276..2,476]	~ overlap (-1.4%)

float16array.js — Interp: 🟢 7, 🔴 2, 23 unch. · avg +0.4% · Bytecode: 🟢 1, 31 unch. · avg +0.5%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
new Float16Array(0)	91,077 ops/sec [89,184..104,300] → 91,586 ops/sec [90,769..92,373]	~ overlap (+0.6%)	107,774 ops/sec [106,938..109,682] → 108,264 ops/sec [104,656..109,087]	~ overlap (+0.5%)
new Float16Array(100)	88,031 ops/sec [86,869..88,442] → 88,498 ops/sec [87,309..92,288]	~ overlap (+0.5%)	106,412 ops/sec [106,127..106,580] → 106,694 ops/sec [100,861..112,638]	~ overlap (+0.3%)
new Float16Array(1000)	79,552 ops/sec [78,528..81,800] → 81,245 ops/sec [78,794..82,319]	~ overlap (+2.1%)	92,159 ops/sec [91,278..92,613] → 99,266 ops/sec [90,506..111,905]	~ overlap (+7.7%)
Float16Array.from([...100])	1,534 ops/sec [1,530..1,537] → 1,640 ops/sec [1,608..2,395]	🟢 +6.9%	1,551 ops/sec [1,538..1,561] → 1,604 ops/sec [1,516..1,858]	~ overlap (+3.4%)
Float16Array.of(1.5, 2.5, 3.5, 4.5, 5.5)	76,523 ops/sec [76,201..76,869] → 80,127 ops/sec [79,792..80,644]	🟢 +4.7%	74,620 ops/sec [72,236..74,988] → 71,935 ops/sec [70,859..72,469]	~ overlap (-3.6%)
new Float16Array(float64Array)	21,669 ops/sec [21,608..21,722] → 22,816 ops/sec [22,600..24,072]	🟢 +5.3%	26,529 ops/sec [25,963..26,645] → 26,536 ops/sec [26,134..26,770]	~ overlap (+0.0%)
sequential write 100 elements	1,046 ops/sec [1,025..1,053] → 1,040 ops/sec [1,027..1,285]	~ overlap (-0.5%)	4,175 ops/sec [4,080..4,866] → 4,296 ops/sec [4,194..4,392]	~ overlap (+2.9%)
sequential read 100 elements	1,214 ops/sec [1,172..1,265] → 1,155 ops/sec [1,151..1,156]	🔴 -4.9%	6,153 ops/sec [6,003..6,526] → 6,253 ops/sec [5,988..6,644]	~ overlap (+1.6%)
write special values (NaN, Inf, -0)	45,746 ops/sec [44,406..52,478] → 45,610 ops/sec [44,530..46,455]	~ overlap (-0.3%)	119,255 ops/sec [109,224..123,048] → 119,249 ops/sec [118,042..119,934]	~ overlap (-0.0%)
Float16Array write	1,046 ops/sec [1,043..1,048] → 1,100 ops/sec [1,075..1,141]	🟢 +5.2%	4,212 ops/sec [4,126..4,264] → 4,294 ops/sec [4,239..4,306]	~ overlap (+1.9%)
Float32Array write	1,047 ops/sec [1,032..1,052] → 1,106 ops/sec [1,082..1,109]	🟢 +5.6%	4,215 ops/sec [4,162..4,240] → 4,285 ops/sec [4,053..4,323]	~ overlap (+1.7%)
Float64Array write	1,037 ops/sec [1,036..1,039] → 1,066 ops/sec [1,055..1,073]	🟢 +2.8%	4,197 ops/sec [4,166..4,221] → 4,119 ops/sec [4,063..4,442]	~ overlap (-1.9%)
Float16Array read	1,128 ops/sec [1,127..1,159] → 1,154 ops/sec [1,139..1,173]	~ overlap (+2.3%)	5,530 ops/sec [5,252..5,753] → 5,400 ops/sec [5,334..5,532]	~ overlap (-2.3%)
Float32Array read	1,165 ops/sec [1,128..1,209] → 1,169 ops/sec [1,160..1,176]	~ overlap (+0.4%)	5,882 ops/sec [5,821..6,089] → 6,508 ops/sec [5,703..6,738]	~ overlap (+10.7%)
Float64Array read	1,160 ops/sec [1,151..1,162] → 1,172 ops/sec [1,160..1,175]	~ overlap (+1.1%)	5,692 ops/sec [5,620..6,614] → 5,595 ops/sec [5,260..6,261]	~ overlap (-1.7%)
fill(1.5)	5,800 ops/sec [5,628..5,840] → 5,881 ops/sec [5,874..5,951]	🟢 +1.4%	6,887 ops/sec [6,817..7,036] → 6,620 ops/sec [6,560..7,308]	~ overlap (-3.9%)
slice()	11,152 ops/sec [10,788..12,796] → 11,230 ops/sec [11,163..11,297]	~ overlap (+0.7%)	11,540 ops/sec [11,347..17,902] → 12,254 ops/sec [11,616..12,424]	~ overlap (+6.2%)
map(x => x * 2)	2,178 ops/sec [2,151..2,251] → 2,193 ops/sec [2,159..2,204]	~ overlap (+0.7%)	2,165 ops/sec [2,096..2,198] → 2,236 ops/sec [2,201..2,712]	🟢 +3.3%
filter(x => x > 25)	2,195 ops/sec [2,177..2,371] → 2,273 ops/sec [2,166..2,376]	~ overlap (+3.6%)	2,307 ops/sec [2,273..2,342] → 2,325 ops/sec [2,295..2,529]	~ overlap (+0.8%)
reduce (sum)	2,107 ops/sec [2,063..2,133] → 2,113 ops/sec [2,026..2,489]	~ overlap (+0.3%)	2,050 ops/sec [2,041..2,089] → 2,048 ops/sec [2,030..2,102]	~ overlap (-0.1%)
sort()	18,060 ops/sec [17,999..18,078] → 18,661 ops/sec [17,649..20,672]	~ overlap (+3.3%)	19,822 ops/sec [19,390..20,205] → 19,933 ops/sec [19,749..22,255]	~ overlap (+0.6%)
indexOf()	24,850 ops/sec [24,545..29,133] → 24,734 ops/sec [24,389..28,081]	~ overlap (-0.5%)	27,061 ops/sec [26,466..29,178] → 27,213 ops/sec [26,812..27,679]	~ overlap (+0.6%)
reverse()	24,394 ops/sec [23,791..29,176] → 25,231 ops/sec [24,459..25,698]	~ overlap (+3.4%)	29,769 ops/sec [29,448..41,202] → 29,457 ops/sec [29,392..29,644]	~ overlap (-1.0%)
toReversed()	20,576 ops/sec [20,256..20,829] → 20,841 ops/sec [20,726..20,874]	~ overlap (+1.3%)	24,764 ops/sec [23,369..25,417] → 22,754 ops/sec [22,322..24,896]	~ overlap (-8.1%)
toSorted()	10,178 ops/sec [10,031..10,358] → 10,636 ops/sec [10,037..11,447]	~ overlap (+4.5%)	11,549 ops/sec [11,051..12,320] → 11,366 ops/sec [11,061..11,465]	~ overlap (-1.6%)
create view over existing buffer	100,948 ops/sec [98,037..126,601] → 100,111 ops/sec [97,601..105,050]	~ overlap (-0.8%)	126,374 ops/sec [114,233..138,781] → 121,640 ops/sec [114,968..135,660]	~ overlap (-3.7%)
subarray()	67,940 ops/sec [66,470..80,661] → 68,881 ops/sec [68,428..75,244]	~ overlap (+1.4%)	81,687 ops/sec [75,974..84,634] → 75,726 ops/sec [74,622..109,668]	~ overlap (-7.3%)
set() from array	106,123 ops/sec [97,543..118,384] → 100,826 ops/sec [99,971..101,371]	~ overlap (-5.0%)	141,536 ops/sec [129,746..147,762] → 128,662 ops/sec [126,649..132,739]	~ overlap (-9.1%)
for-of loop	1,747 ops/sec [1,540..1,852] → 1,591 ops/sec [1,570..1,595]	~ overlap (-8.9%)	6,176 ops/sec [6,034..8,322] → 6,506 ops/sec [6,328..6,705]	~ overlap (+5.3%)
spread into array	7,321 ops/sec [6,345..9,453] → 6,309 ops/sec [6,253..7,364]	~ overlap (-13.8%)	23,114 ops/sec [21,641..24,882] → 25,143 ops/sec [23,512..25,247]	~ overlap (+8.8%)
f16round(1.337)	196,124 ops/sec [181,783..205,047] → 179,058 ops/sec [175,258..181,573]	🔴 -8.7%	231,820 ops/sec [217,745..262,638] → 242,926 ops/sec [223,269..292,886]	~ overlap (+4.8%)
f16round over 100 values	1,295 ops/sec [1,144..1,440] → 1,266 ops/sec [1,109..1,323]	~ overlap (-2.3%)	3,147 ops/sec [2,941..3,476] → 3,123 ops/sec [3,094..3,200]	~ overlap (-0.8%)

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

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for...in over 50 own keys	2,938 ops/sec [2,908..2,953] → 2,897 ops/sec [2,868..2,957]	~ overlap (-1.4%)	3,730 ops/sec [3,634..4,016] → 4,960 ops/sec [4,834..5,064]	🟢 +33.0%
for...in over an 8-level chain of 50 shared keys	2,085 ops/sec [2,057..2,451] → 2,061 ops/sec [2,040..2,401]	~ overlap (-1.1%)	2,839 ops/sec [2,743..3,133] → 3,126 ops/sec [2,894..3,562]	~ overlap (+10.1%)
for...in over a 16-level chain of 100 shared keys	798 ops/sec [797..801] → 794 ops/sec [788..948]	~ overlap (-0.5%)	1,115 ops/sec [1,113..1,122] → 1,125 ops/sec [1,116..1,131]	~ overlap (+0.8%)

for-of.js — Interp: 🔴 1, 6 unch. · avg -1.2% · Bytecode: 🔴 2, 5 unch. · avg -6.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for...of with 10-element array	14,040 ops/sec [13,990..16,037] → 14,022 ops/sec [13,934..14,642]	~ overlap (-0.1%)	75,166 ops/sec [74,800..75,266] → 74,768 ops/sec [73,290..74,982]	~ overlap (-0.5%)
for...of with 100-element array	1,626 ops/sec [1,607..1,665] → 1,623 ops/sec [1,618..1,630]	~ overlap (-0.2%)	10,270 ops/sec [10,156..10,459] → 10,094 ops/sec [10,034..10,806]	~ overlap (-1.7%)
for...of with string (10 chars)	10,967 ops/sec [10,898..12,927] → 10,867 ops/sec [10,836..10,874]	🔴 -0.9%	27,381 ops/sec [27,147..27,760] → 27,112 ops/sec [26,770..27,352]	~ overlap (-1.0%)
for...of with Set (10 elements)	15,840 ops/sec [14,245..17,301] → 15,414 ops/sec [15,053..15,424]	~ overlap (-2.7%)	85,786 ops/sec [85,081..99,451] → 83,074 ops/sec [76,950..87,722]	~ overlap (-3.2%)
for...of with Map entries (10 entries)	7,645 ops/sec [7,469..8,858] → 7,501 ops/sec [7,384..7,599]	~ overlap (-1.9%)	12,799 ops/sec [12,636..13,136] → 10,764 ops/sec [10,638..10,782]	🔴 -15.9%
for...of with destructuring	8,466 ops/sec [8,377..8,573] → 8,344 ops/sec [8,277..10,684]	~ overlap (-1.4%)	15,838 ops/sec [14,702..16,788] → 13,080 ops/sec [12,774..14,028]	🔴 -17.4%
for-await-of with sync array	9,008 ops/sec [8,910..12,228] → 8,910 ops/sec [8,660..11,446]	~ overlap (-1.1%)	1,799 ops/sec [1,619..2,016] → 1,751 ops/sec [1,625..1,939]	~ overlap (-2.6%)

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

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
manual next over object generator	770 ops/sec [694..842] → 671 ops/sec [665..676]	🔴 -12.8%	1,034 ops/sec [1,029..1,048] → 1,056 ops/sec [1,050..1,133]	🟢 +2.2%
for...of over object generator	1,016 ops/sec [1,012..1,133] → 976 ops/sec [959..979]	🔴 -3.9%	1,497 ops/sec [1,451..1,521] → 1,526 ops/sec [1,522..1,543]	🟢 +2.0%
yield delegation	1,024 ops/sec [984..1,029] → 972 ops/sec [964..1,029]	~ overlap (-5.1%)	1,502 ops/sec [1,489..1,670] → 1,538 ops/sec [1,531..1,552]	~ overlap (+2.4%)
class generator method	1,027 ops/sec [1,004..1,116] → 1,029 ops/sec [926..1,069]	~ overlap (+0.1%)	1,325 ops/sec [1,313..1,338] → 1,524 ops/sec [1,511..1,536]	🟢 +15.0%

intl.js — Interp: 🔴 2, 4 unch. · avg -1.9% · Bytecode: 6 unch. · avg +3.3%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
format decimal	26,474 ops/sec [24,525..31,726] → 25,858 ops/sec [25,433..26,477]	~ overlap (-2.3%)	24,917 ops/sec [24,420..29,707] → 25,803 ops/sec [25,759..26,465]	~ overlap (+3.6%)
format currency	19,805 ops/sec [19,435..20,092] → 20,081 ops/sec [19,994..20,261]	~ overlap (+1.4%)	21,189 ops/sec [19,493..22,081] → 20,388 ops/sec [20,357..20,523]	~ overlap (-3.8%)
format UTC date	2,653 ops/sec [2,606..2,811] → 2,654 ops/sec [2,579..2,732]	~ overlap (+0.0%)	2,465 ops/sec [2,375..2,625] → 2,548 ops/sec [2,459..2,619]	~ overlap (+3.3%)
formatRange UTC dates	3,763 ops/sec [3,607..4,161] → 3,508 ops/sec [3,447..3,528]	🔴 -6.8%	3,091 ops/sec [3,037..3,156] → 3,303 ops/sec [3,144..3,429]	~ overlap (+6.9%)
compare numeric strings	98,057 ops/sec [97,340..100,093] → 92,949 ops/sec [92,785..93,669]	🔴 -5.2%	103,382 ops/sec [102,628..103,591] → 112,796 ops/sec [89,071..128,790]	~ overlap (+9.1%)
sort short string list	18,435 ops/sec [18,256..19,750] → 18,707 ops/sec [18,470..18,794]	~ overlap (+1.5%)	19,762 ops/sec [19,385..20,120] → 19,927 ops/sec [19,399..20,202]	~ overlap (+0.8%)

iterators.js — Interp: 🟢 1, 🔴 3, 38 unch. · avg -0.9% · Bytecode: 🟢 4, 🔴 2, 36 unch. · avg +1.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Iterator.from({next}).toArray() — 20 elements	2,777 ops/sec [2,758..2,867] → 2,941 ops/sec [2,872..3,046]	🟢 +5.9%	4,003 ops/sec [3,919..4,030] → 4,021 ops/sec [4,010..4,031]	~ overlap (+0.5%)
Iterator.from({next}).toArray() — 50 elements	1,312 ops/sec [1,299..1,319] → 1,179 ops/sec [1,161..1,255]	🔴 -10.1%	1,703 ops/sec [1,688..2,288] → 1,709 ops/sec [1,697..1,728]	~ overlap (+0.4%)
spread pre-wrapped iterator — 20 elements	3,142 ops/sec [3,067..3,488] → 3,003 ops/sec [2,939..3,021]	🔴 -4.4%	5,515 ops/sec [5,486..5,552] → 5,476 ops/sec [5,367..5,518]	~ overlap (-0.7%)
Iterator.from({next}).forEach — 50 elements	912 ops/sec [894..1,013] → 889 ops/sec [876..999]	~ overlap (-2.5%)	1,349 ops/sec [1,309..1,406] → 1,306 ops/sec [1,296..1,307]	🔴 -3.2%
Iterator.from({next}).reduce — 50 elements	996 ops/sec [993..1,007] → 991 ops/sec [946..1,029]	~ overlap (-0.6%)	1,297 ops/sec [1,284..1,376] → 1,258 ops/sec [1,252..1,318]	~ overlap (-3.0%)
wrap array iterator	17,950 ops/sec [17,745..21,999] → 18,718 ops/sec [18,107..19,061]	~ overlap (+4.3%)	18,438 ops/sec [17,789..18,549] → 18,298 ops/sec [18,105..20,623]	~ overlap (-0.8%)
wrap plain {next()} object	1,991 ops/sec [1,966..2,019] → 2,008 ops/sec [1,964..2,014]	~ overlap (+0.9%)	2,750 ops/sec [2,716..2,768] → 2,734 ops/sec [2,715..2,981]	~ overlap (-0.6%)
map + toArray (50 elements)	805 ops/sec [758..848] → 763 ops/sec [741..766]	~ overlap (-5.3%)	909 ops/sec [903..913] → 907 ops/sec [893..915]	~ overlap (-0.3%)
filter + toArray (50 elements)	809 ops/sec [804..930] → 802 ops/sec [771..992]	~ overlap (-0.9%)	983 ops/sec [971..990] → 1,001 ops/sec [982..1,010]	~ overlap (+1.9%)
take(10) + toArray (50 element source)	4,224 ops/sec [4,217..4,238] → 4,167 ops/sec [4,070..4,711]	~ overlap (-1.3%)	4,934 ops/sec [4,862..4,988] → 5,120 ops/sec [4,916..5,223]	~ overlap (+3.8%)
drop(40) + toArray (50 element source)	1,063 ops/sec [1,057..1,292] → 1,053 ops/sec [1,038..1,103]	~ overlap (-0.9%)	1,331 ops/sec [1,307..1,410] → 1,311 ops/sec [1,300..1,314]	~ overlap (-1.5%)
chained map + filter + take (100 element source)	1,343 ops/sec [1,157..1,748] → 1,281 ops/sec [1,260..1,293]	~ overlap (-4.6%)	1,394 ops/sec [1,368..1,442] → 1,437 ops/sec [1,406..1,453]	~ overlap (+3.1%)
some + every (50 elements)	562 ops/sec [561..663] → 554 ops/sec [538..807]	~ overlap (-1.6%)	702 ops/sec [690..720] → 718 ops/sec [703..741]	~ overlap (+2.4%)
find (50 elements)	1,237 ops/sec [1,224..1,242] → 1,231 ops/sec [1,219..1,890]	~ overlap (-0.5%)	1,574 ops/sec [1,526..1,588] → 1,629 ops/sec [1,579..1,714]	~ overlap (+3.5%)
concat 2 arrays (10 + 10 elements)	7,175 ops/sec [6,942..12,181] → 6,900 ops/sec [6,777..7,035]	~ overlap (-3.8%)	6,989 ops/sec [6,476..7,596] → 6,637 ops/sec [6,446..8,515]	~ overlap (-5.0%)
concat 5 arrays (10 elements each)	3,120 ops/sec [2,925..3,945] → 3,030 ops/sec [3,002..3,052]	~ overlap (-2.9%)	2,836 ops/sec [2,745..2,846] → 2,903 ops/sec [2,831..4,050]	~ overlap (+2.4%)
concat 2 arrays (20 + 20 elements)	4,613 ops/sec [3,911..5,229] → 4,574 ops/sec [3,743..4,873]	~ overlap (-0.8%)	3,603 ops/sec [3,460..3,709] → 3,751 ops/sec [3,668..4,126]	~ overlap (+4.1%)
concat + filter + toArray (20 + 20 elements)	1,867 ops/sec [1,591..2,582] → 1,759 ops/sec [1,584..1,891]	~ overlap (-5.8%)	1,642 ops/sec [1,605..1,829] → 1,647 ops/sec [1,634..1,678]	~ overlap (+0.3%)
concat + map + take (20 + 20 elements, take 10)	4,094 ops/sec [4,006..4,227] → 4,398 ops/sec [4,081..4,653]	~ overlap (+7.4%)	3,921 ops/sec [3,850..4,655] → 4,008 ops/sec [3,926..4,926]	~ overlap (+2.2%)
concat Sets (15 + 15 elements)	5,033 ops/sec [4,917..5,172] → 5,573 ops/sec [5,048..5,713]	~ overlap (+10.7%)	4,556 ops/sec [4,431..4,680] → 4,862 ops/sec [4,766..5,616]	🟢 +6.7%
concat strings (13 + 13 characters)	5,974 ops/sec [5,374..6,640] → 5,540 ops/sec [5,330..5,592]	~ overlap (-7.3%)	5,250 ops/sec [5,200..5,308] → 5,089 ops/sec [5,002..5,622]	~ overlap (-3.1%)
zip 2 arrays (10 + 10 elements)	13,997 ops/sec [13,972..14,055] → 13,695 ops/sec [12,407..16,040]	~ overlap (-2.2%)	12,311 ops/sec [11,930..13,671] → 11,698 ops/sec [11,664..17,357]	~ overlap (-5.0%)
zip 3 arrays (10 elements each)	12,578 ops/sec [12,116..13,334] → 11,509 ops/sec [11,321..12,231]	~ overlap (-8.5%)	11,558 ops/sec [11,516..11,578] → 11,088 ops/sec [10,999..11,206]	🔴 -4.1%
zip 2 arrays (20 + 20 elements)	8,654 ops/sec [7,701..9,033] → 8,065 ops/sec [7,713..9,631]	~ overlap (-6.8%)	7,256 ops/sec [6,999..7,327] → 7,062 ops/sec [7,021..9,494]	~ overlap (-2.7%)
zip 2 arrays (50 + 50 elements)	3,539 ops/sec [3,339..3,627] → 3,863 ops/sec [3,357..4,030]	~ overlap (+9.2%)	3,301 ops/sec [3,218..3,336] → 3,306 ops/sec [3,255..3,359]	~ overlap (+0.1%)
zip shortest mode (20 + 10 elements)	12,332 ops/sec [12,283..13,776] → 12,501 ops/sec [12,352..14,250]	~ overlap (+1.4%)	12,107 ops/sec [11,523..12,161] → 12,722 ops/sec [9,417..15,297]	~ overlap (+5.1%)
zip longest mode (10 + 20 elements)	7,106 ops/sec [7,019..10,341] → 7,120 ops/sec [7,064..9,893]	~ overlap (+0.2%)	6,898 ops/sec [6,853..6,919] → 6,961 ops/sec [6,406..7,681]	~ overlap (+0.9%)
zip strict mode (20 + 20 elements)	7,781 ops/sec [7,729..7,893] → 7,383 ops/sec [7,311..7,439]	🔴 -5.1%	7,478 ops/sec [6,987..7,572] → 7,278 ops/sec [7,225..7,371]	~ overlap (-2.7%)
zip + map + toArray (20 + 20 elements)	2,381 ops/sec [2,320..3,184] → 2,540 ops/sec [2,397..2,618]	~ overlap (+6.7%)	2,143 ops/sec [2,127..2,364] → 2,195 ops/sec [2,115..2,635]	~ overlap (+2.4%)
zip + filter + toArray (20 + 20 elements)	2,686 ops/sec [2,518..3,067] → 2,560 ops/sec [2,418..2,945]	~ overlap (-4.7%)	2,293 ops/sec [2,268..2,363] → 2,414 ops/sec [2,205..2,528]	~ overlap (+5.3%)
zip Sets (15 + 15 elements)	9,783 ops/sec [9,693..13,161] → 10,084 ops/sec [9,779..12,095]	~ overlap (+3.1%)	10,030 ops/sec [9,373..10,555] → 9,961 ops/sec [9,683..11,227]	~ overlap (-0.7%)
zipKeyed 2 keys (10 elements each)	14,240 ops/sec [12,030..17,453] → 12,471 ops/sec [12,025..13,321]	~ overlap (-12.4%)	12,651 ops/sec [11,609..13,785] → 11,789 ops/sec [11,196..12,432]	~ overlap (-6.8%)
zipKeyed 3 keys (20 elements each)	6,347 ops/sec [5,919..6,807] → 6,242 ops/sec [6,057..6,616]	~ overlap (-1.7%)	6,046 ops/sec [5,895..6,227] → 6,630 ops/sec [5,943..7,408]	~ overlap (+9.7%)
zipKeyed longest mode (10 + 20 elements)	7,006 ops/sec [6,957..7,024] → 6,978 ops/sec [6,765..8,168]	~ overlap (-0.4%)	6,548 ops/sec [6,542..6,582] → 6,831 ops/sec [6,404..9,209]	~ overlap (+4.3%)
zipKeyed strict mode (20 + 20 elements)	7,520 ops/sec [6,888..9,370] → 7,260 ops/sec [6,813..10,148]	~ overlap (-3.5%)	6,695 ops/sec [6,644..6,816] → 6,878 ops/sec [6,630..7,330]	~ overlap (+2.7%)
zipKeyed + filter + map (20 elements)	2,213 ops/sec [2,190..2,248] → 2,497 ops/sec [2,106..2,691]	~ overlap (+12.8%)	2,297 ops/sec [2,285..3,112] → 2,404 ops/sec [2,384..2,416]	~ overlap (+4.7%)
array.values().map().filter().toArray()	922 ops/sec [871..1,146] → 955 ops/sec [876..1,118]	~ overlap (+3.6%)	858 ops/sec [852..875] → 922 ops/sec [916..923]	🟢 +7.5%
array.values().take(5).toArray()	15,084 ops/sec [14,670..16,105] → 15,310 ops/sec [14,924..15,405]	~ overlap (+1.5%)	14,989 ops/sec [14,986..15,055] → 15,554 ops/sec [15,267..15,845]	🟢 +3.8%
array.values().drop(45).toArray()	3,333 ops/sec [3,316..3,406] → 3,313 ops/sec [3,211..3,485]	~ overlap (-0.6%)	3,097 ops/sec [3,063..3,799] → 3,126 ops/sec [3,090..3,986]	~ overlap (+0.9%)
map.entries() chained helpers	1,236 ops/sec [1,233..1,256] → 1,260 ops/sec [1,241..1,279]	~ overlap (+2.0%)	1,172 ops/sec [1,104..1,182] → 1,195 ops/sec [1,169..1,485]	~ overlap (+1.9%)
set.values() chained helpers	2,307 ops/sec [2,088..2,723] → 2,142 ops/sec [2,087..2,192]	~ overlap (-7.2%)	2,204 ops/sec [2,129..2,306] → 2,301 ops/sec [2,285..2,335]	~ overlap (+4.4%)
string iterator map + toArray	2,142 ops/sec [2,095..2,644] → 2,146 ops/sec [2,100..2,239]	~ overlap (+0.2%)	2,088 ops/sec [2,081..2,104] → 2,205 ops/sec [2,158..2,217]	🟢 +5.6%

json.js — Interp: 🔴 6, 17 unch. · avg -2.6% · Bytecode: 🟢 1, 🔴 5, 17 unch. · avg -0.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple object	58,638 ops/sec [58,132..65,453] → 60,539 ops/sec [60,319..60,607]	~ overlap (+3.2%)	64,113 ops/sec [63,062..69,259] → 66,636 ops/sec [66,035..67,226]	~ overlap (+3.9%)
parse nested object	40,826 ops/sec [40,043..41,386] → 41,016 ops/sec [40,846..41,325]	~ overlap (+0.5%)	45,444 ops/sec [41,896..48,684] → 43,362 ops/sec [43,274..43,681]	~ overlap (-4.6%)
parse array of objects	26,437 ops/sec [26,249..30,859] → 26,235 ops/sec [24,538..28,373]	~ overlap (-0.8%)	25,748 ops/sec [25,475..25,923] → 26,800 ops/sec [25,356..28,898]	~ overlap (+4.1%)
parse large flat object	27,811 ops/sec [27,741..28,012] → 25,807 ops/sec [25,491..26,162]	🔴 -7.2%	28,356 ops/sec [27,311..28,862] → 28,590 ops/sec [27,688..32,152]	~ overlap (+0.8%)
parse mixed types	34,150 ops/sec [32,430..37,544] → 31,384 ops/sec [31,019..31,506]	🔴 -8.1%	35,172 ops/sec [34,881..51,663] → 32,911 ops/sec [32,605..33,024]	🔴 -6.4%
stringify simple object	60,857 ops/sec [59,870..75,845] → 60,942 ops/sec [57,927..73,079]	~ overlap (+0.1%)	57,574 ops/sec [57,162..57,815] → 54,081 ops/sec [53,827..57,349]	~ overlap (-6.1%)
stringify nested object	36,861 ops/sec [36,793..37,070] → 35,879 ops/sec [35,541..36,066]	🔴 -2.7%	32,546 ops/sec [30,697..34,867] → 31,261 ops/sec [30,313..32,373]	~ overlap (-3.9%)
stringify array of objects	16,838 ops/sec [16,670..18,586] → 16,906 ops/sec [16,656..17,492]	~ overlap (+0.4%)	17,576 ops/sec [17,519..17,741] → 17,541 ops/sec [16,445..20,115]	~ overlap (-0.2%)
stringify mixed types	25,387 ops/sec [25,028..30,825] → 25,602 ops/sec [24,603..26,361]	~ overlap (+0.8%)	22,264 ops/sec [21,594..23,027] → 21,927 ops/sec [21,734..22,136]	~ overlap (-1.5%)
reviver doubles numbers	10,350 ops/sec [10,119..10,505] → 10,790 ops/sec [9,834..12,086]	~ overlap (+4.2%)	14,178 ops/sec [13,824..14,674] → 14,020 ops/sec [13,680..14,263]	~ overlap (-1.1%)
reviver filters properties	10,265 ops/sec [10,174..10,297] → 9,946 ops/sec [9,740..10,142]	🔴 -3.1%	12,839 ops/sec [12,620..15,148] → 12,647 ops/sec [12,288..15,134]	~ overlap (-1.5%)
reviver on nested object	12,619 ops/sec [12,066..13,847] → 11,725 ops/sec [11,662..12,040]	🔴 -7.1%	15,769 ops/sec [15,441..18,008] → 16,204 ops/sec [14,883..16,890]	~ overlap (+2.8%)
reviver on array	6,524 ops/sec [6,453..6,531] → 6,644 ops/sec [6,011..7,277]	~ overlap (+1.8%)	9,113 ops/sec [9,068..9,388] → 8,637 ops/sec [8,358..8,941]	🔴 -5.2%
replacer function doubles numbers	11,257 ops/sec [11,008..12,871] → 11,289 ops/sec [10,986..11,641]	~ overlap (+0.3%)	17,386 ops/sec [15,073..17,968] → 14,870 ops/sec [14,694..15,040]	🔴 -14.5%
replacer function excludes properties	15,521 ops/sec [14,638..18,129] → 14,726 ops/sec [14,651..14,776]	~ overlap (-5.1%)	19,836 ops/sec [19,582..20,057] → 18,494 ops/sec [18,177..18,684]	🔴 -6.8%
array replacer (allowlist)	47,688 ops/sec [39,863..50,652] → 38,769 ops/sec [38,426..48,255]	~ overlap (-18.7%)	32,217 ops/sec [32,059..34,935] → 34,900 ops/sec [34,480..35,592]	~ overlap (+8.3%)
stringify with 2-space indent	35,161 ops/sec [33,723..35,913] → 32,484 ops/sec [31,832..32,616]	🔴 -7.6%	31,108 ops/sec [30,934..31,279] → 30,719 ops/sec [30,539..30,748]	🔴 -1.3%
stringify with tab indent	33,405 ops/sec [33,241..40,845] → 32,865 ops/sec [32,564..35,115]	~ overlap (-1.6%)	28,525 ops/sec [28,211..28,618] → 32,182 ops/sec [30,572..34,873]	🟢 +12.8%
stringify deeply nested object with 2-space indent	7,124 ops/sec [7,018..7,265] → 7,011 ops/sec [6,808..9,219]	~ overlap (-1.6%)	6,408 ops/sec [6,331..7,625] → 6,833 ops/sec [6,690..7,019]	~ overlap (+6.6%)
stringify deeply nested array with 2-space indent	10,337 ops/sec [10,174..10,944] → 10,124 ops/sec [9,784..10,856]	~ overlap (-2.1%)	9,703 ops/sec [9,638..9,768] → 9,443 ops/sec [9,331..10,002]	~ overlap (-2.7%)
stringify very deeply nested object with 2-space indent	1,258 ops/sec [1,241..1,834] → 1,249 ops/sec [1,241..1,282]	~ overlap (-0.7%)	1,199 ops/sec [1,153..1,212] → 1,178 ops/sec [1,143..1,212]	~ overlap (-1.8%)
parse then stringify	20,996 ops/sec [20,366..35,307] → 20,368 ops/sec [19,706..22,281]	~ overlap (-3.0%)	21,639 ops/sec [21,457..21,927] → 20,949 ops/sec [20,772..24,661]	~ overlap (-3.2%)
stringify then parse	12,721 ops/sec [12,587..12,982] → 12,401 ops/sec [12,215..14,633]	~ overlap (-2.5%)	12,794 ops/sec [12,534..13,618] → 12,979 ops/sec [12,419..13,600]	~ overlap (+1.4%)

jsx.jsx — Interp: 🟢 3, 18 unch. · avg +3.7% · Bytecode: 🟢 1, 🔴 1, 19 unch. · avg -3.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple element	74,231 ops/sec [71,331..78,767] → 90,498 ops/sec [87,556..90,775]	🟢 +21.9%	88,616 ops/sec [86,373..93,431] → 88,338 ops/sec [83,835..102,506]	~ overlap (-0.3%)
self-closing element	77,843 ops/sec [75,976..78,232] → 77,025 ops/sec [76,286..77,616]	~ overlap (-1.1%)	93,027 ops/sec [92,766..93,373] → 100,223 ops/sec [93,691..109,209]	🟢 +7.7%
element with string attribute	65,735 ops/sec [64,985..66,134] → 67,221 ops/sec [65,972..67,644]	~ overlap (+2.3%)	71,407 ops/sec [70,881..75,885] → 73,243 ops/sec [71,537..82,464]	~ overlap (+2.6%)
element with multiple attributes	57,333 ops/sec [55,856..64,839] → 64,023 ops/sec [58,710..70,433]	~ overlap (+11.7%)	51,844 ops/sec [51,496..71,925] → 51,865 ops/sec [51,820..52,675]	~ overlap (+0.0%)
element with expression attribute	59,804 ops/sec [58,564..85,543] → 61,770 ops/sec [61,305..72,403]	~ overlap (+3.3%)	70,581 ops/sec [69,736..102,690] → 72,617 ops/sec [72,435..72,661]	~ overlap (+2.9%)
text child	74,407 ops/sec [72,874..82,999] → 81,111 ops/sec [80,132..87,119]	~ overlap (+9.0%)	86,204 ops/sec [82,649..114,659] → 87,467 ops/sec [85,086..92,292]	~ overlap (+1.5%)
expression child	72,096 ops/sec [70,786..79,161] → 74,650 ops/sec [72,869..127,785]	~ overlap (+3.5%)	81,679 ops/sec [79,353..82,142] → 82,428 ops/sec [79,221..87,553]	~ overlap (+0.9%)
mixed text and expression	68,070 ops/sec [67,801..75,487] → 71,703 ops/sec [70,962..72,961]	~ overlap (+5.3%)	77,595 ops/sec [74,447..80,122] → 75,797 ops/sec [73,057..76,174]	~ overlap (-2.3%)
nested elements (3 levels)	32,020 ops/sec [30,161..40,153] → 33,688 ops/sec [31,607..34,794]	~ overlap (+5.2%)	39,083 ops/sec [33,670..51,321] → 36,167 ops/sec [32,694..40,523]	~ overlap (-7.5%)
sibling children	22,926 ops/sec [22,592..29,067] → 23,767 ops/sec [23,513..28,918]	~ overlap (+3.7%)	27,936 ops/sec [24,493..31,077] → 24,726 ops/sec [24,437..25,613]	~ overlap (-11.5%)
component element	54,657 ops/sec [54,177..59,378] → 59,953 ops/sec [57,954..78,265]	~ overlap (+9.7%)	67,152 ops/sec [65,650..77,561] → 65,361 ops/sec [64,422..69,072]	~ overlap (-2.7%)
component with children	34,400 ops/sec [33,500..35,638] → 36,643 ops/sec [34,738..42,437]	~ overlap (+6.5%)	40,186 ops/sec [39,544..48,538] → 38,703 ops/sec [38,528..39,286]	🔴 -3.7%
dotted component	55,522 ops/sec [46,510..59,571] → 50,456 ops/sec [48,297..69,849]	~ overlap (-9.1%)	65,619 ops/sec [52,502..67,256] → 51,578 ops/sec [50,084..52,510]	~ overlap (-21.4%)
empty fragment	87,725 ops/sec [77,236..119,071] → 81,358 ops/sec [79,693..82,092]	~ overlap (-7.3%)	103,693 ops/sec [96,988..105,287] → 97,158 ops/sec [95,074..98,803]	~ overlap (-6.3%)
fragment with children	21,883 ops/sec [21,704..29,860] → 25,773 ops/sec [23,280..29,821]	~ overlap (+17.8%)	25,445 ops/sec [24,088..26,930] → 24,507 ops/sec [23,635..24,659]	~ overlap (-3.7%)
spread attributes	41,367 ops/sec [37,235..43,063] → 42,044 ops/sec [39,574..55,900]	~ overlap (+1.6%)	37,071 ops/sec [36,691..37,381] → 36,610 ops/sec [36,101..38,991]	~ overlap (-1.2%)
spread with overrides	34,198 ops/sec [33,533..39,445] → 35,133 ops/sec [34,954..47,183]	~ overlap (+2.7%)	31,870 ops/sec [31,508..32,241] → 31,633 ops/sec [31,380..31,843]	~ overlap (-0.7%)
shorthand props	55,781 ops/sec [55,545..56,046] → 59,497 ops/sec [58,638..78,086]	🟢 +6.7%	56,912 ops/sec [56,407..57,220] → 56,459 ops/sec [55,894..58,602]	~ overlap (-0.8%)
nav bar structure	10,784 ops/sec [10,686..10,848] → 11,665 ops/sec [11,564..13,309]	🟢 +8.2%	11,156 ops/sec [11,090..12,360] → 11,020 ops/sec [10,937..11,118]	~ overlap (-1.2%)
card component tree	14,726 ops/sec [12,740..16,868] → 13,229 ops/sec [12,913..17,460]	~ overlap (-10.2%)	12,360 ops/sec [12,329..15,935] → 12,330 ops/sec [12,229..12,375]	~ overlap (-0.2%)
10 list items via Array.from	6,816 ops/sec [5,517..7,110] → 5,873 ops/sec [5,846..7,256]	~ overlap (-13.8%)	6,721 ops/sec [5,569..6,925] → 5,113 ops/sec [5,016..5,960]	~ overlap (-23.9%)

modules.js — Interp: 🔴 2, 7 unch. · avg -2.3% · Bytecode: 🔴 1, 8 unch. · avg -0.5%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
call imported function	137,072 ops/sec [127,100..198,679] → 130,496 ops/sec [126,614..144,576]	~ overlap (-4.8%)	45,755 ops/sec [43,944..48,584] → 46,021 ops/sec [44,780..46,743]	~ overlap (+0.6%)
call two imported functions	74,269 ops/sec [71,543..76,442] → 77,663 ops/sec [74,761..77,725]	~ overlap (+4.6%)	23,956 ops/sec [23,495..28,331] → 23,414 ops/sec [23,125..24,097]	~ overlap (-2.3%)
read imported constant	346,840 ops/sec [336,771..429,374] → 345,756 ops/sec [331,681..430,669]	~ overlap (-0.3%)	48,468 ops/sec [47,412..49,154] → 48,763 ops/sec [48,149..48,957]	~ overlap (+0.6%)
read imported string	359,271 ops/sec [336,930..371,968] → 354,276 ops/sec [346,196..405,459]	~ overlap (-1.4%)	47,765 ops/sec [47,478..67,004] → 51,272 ops/sec [47,639..52,277]	~ overlap (+7.3%)
read JSON string property	353,614 ops/sec [350,451..361,195] → 344,837 ops/sec [343,686..348,047]	🔴 -2.5%	49,378 ops/sec [47,929..49,675] → 49,240 ops/sec [47,575..53,198]	~ overlap (-0.3%)
read JSON number property	351,226 ops/sec [343,821..354,604] → 347,634 ops/sec [344,235..354,882]	~ overlap (-1.0%)	53,691 ops/sec [53,110..54,249] → 50,039 ops/sec [48,243..52,208]	🔴 -6.8%
read JSON boolean property	356,857 ops/sec [347,252..423,752] → 347,624 ops/sec [343,890..350,751]	~ overlap (-2.6%)	52,827 ops/sec [49,263..57,737] → 49,903 ops/sec [47,154..53,529]	~ overlap (-5.5%)
read JSON array property	367,700 ops/sec [364,016..368,922] → 340,660 ops/sec [331,008..353,355]	🔴 -7.4%	49,452 ops/sec [49,100..50,134] → 49,367 ops/sec [48,487..49,742]	~ overlap (-0.2%)
read multiple JSON properties	206,910 ops/sec [192,969..251,377] → 196,686 ops/sec [190,120..201,535]	~ overlap (-4.9%)	17,264 ops/sec [16,980..18,218] → 17,629 ops/sec [16,551..19,531]	~ overlap (+2.1%)

numbers.js — Interp: 12 unch. · avg -1.4% · Bytecode: 🔴 1, 11 unch. · avg -0.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
integer arithmetic	102,938 ops/sec [91,681..178,431] → 97,771 ops/sec [94,305..100,472]	~ overlap (-5.0%)	371,774 ops/sec [367,001..394,440] → 365,501 ops/sec [354,582..375,483]	~ overlap (-1.7%)
floating point arithmetic	114,494 ops/sec [114,418..114,874] → 125,898 ops/sec [112,602..135,520]	~ overlap (+10.0%)	256,199 ops/sec [255,654..260,013] → 237,387 ops/sec [203,167..247,104]	🔴 -7.3%
number coercion	43,695 ops/sec [42,300..46,427] → 44,437 ops/sec [43,658..55,925]	~ overlap (+1.7%)	62,207 ops/sec [61,289..77,528] → 63,431 ops/sec [62,508..65,109]	~ overlap (+2.0%)
toFixed	38,571 ops/sec [35,890..44,250] → 37,111 ops/sec [36,304..43,735]	~ overlap (-3.8%)	36,561 ops/sec [35,443..39,705] → 36,416 ops/sec [34,593..38,866]	~ overlap (-0.4%)
toString	56,804 ops/sec [51,776..66,023] → 51,770 ops/sec [51,531..53,328]	~ overlap (-8.9%)	68,219 ops/sec [59,455..75,599] → 62,294 ops/sec [60,003..63,549]	~ overlap (-8.7%)
toString non-integer (shortest round-trip)	5,698 ops/sec [5,678..6,451] → 5,739 ops/sec [5,541..5,754]	~ overlap (+0.7%)	7,088 ops/sec [6,978..7,299] → 7,014 ops/sec [6,757..8,402]	~ overlap (-1.0%)
valueOf	74,292 ops/sec [73,445..74,895] → 72,913 ops/sec [72,578..103,046]	~ overlap (-1.9%)	91,192 ops/sec [89,794..101,367] → 91,984 ops/sec [88,062..103,191]	~ overlap (+0.9%)
toPrecision	24,985 ops/sec [24,236..25,478] → 25,176 ops/sec [24,792..25,624]	~ overlap (+0.8%)	26,392 ops/sec [25,929..32,115] → 28,026 ops/sec [26,502..30,277]	~ overlap (+6.2%)
Number.isNaN	78,570 ops/sec [77,595..79,869] → 80,756 ops/sec [75,423..92,798]	~ overlap (+2.8%)	101,655 ops/sec [100,968..102,047] → 102,050 ops/sec [100,191..103,054]	~ overlap (+0.4%)
Number.isFinite	76,710 ops/sec [74,823..80,940] → 74,827 ops/sec [73,662..75,606]	~ overlap (-2.5%)	91,936 ops/sec [91,739..92,117] → 94,275 ops/sec [91,689..109,446]	~ overlap (+2.5%)
Number.isInteger	79,540 ops/sec [79,268..79,616] → 78,832 ops/sec [78,343..79,660]	~ overlap (-0.9%)	95,542 ops/sec [94,610..125,695] → 97,315 ops/sec [96,100..110,358]	~ overlap (+1.9%)
Number.parseInt and parseFloat	74,918 ops/sec [65,836..99,009] → 67,218 ops/sec [66,779..82,283]	~ overlap (-10.3%)	74,134 ops/sec [72,089..76,414] → 76,688 ops/sec [74,649..78,217]	~ overlap (+3.4%)

objects.js — Interp: 🔴 3, 4 unch. · avg -8.8% · Bytecode: 7 unch. · avg +6.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
create simple object	156,747 ops/sec [154,975..226,750] → 162,905 ops/sec [147,853..170,199]	~ overlap (+3.9%)	127,349 ops/sec [125,528..129,086] → 139,000 ops/sec [125,259..148,751]	~ overlap (+9.1%)
create nested object	103,563 ops/sec [83,162..116,191] → 82,087 ops/sec [80,635..82,366]	🔴 -20.7%	61,330 ops/sec [57,364..62,351] → 67,248 ops/sec [59,490..86,775]	~ overlap (+9.6%)
create 50 objects via Array.from	4,252 ops/sec [3,515..4,542] → 3,330 ops/sec [3,281..3,713]	~ overlap (-21.7%)	2,537 ops/sec [2,445..2,801] → 2,687 ops/sec [2,394..2,932]	~ overlap (+5.9%)
property read	154,549 ops/sec [132,336..174,545] → 147,472 ops/sec [132,929..158,056]	~ overlap (-4.6%)	281,753 ops/sec [260,972..458,432] → 275,294 ops/sec [260,763..307,284]	~ overlap (-2.3%)
Object.keys	85,974 ops/sec [82,362..103,758] → 79,972 ops/sec [79,708..80,429]	🔴 -7.0%	97,604 ops/sec [97,282..98,585] → 97,044 ops/sec [96,721..98,241]	~ overlap (-0.6%)
Object.entries	41,886 ops/sec [41,570..49,733] → 39,853 ops/sec [38,828..44,486]	~ overlap (-4.9%)	44,191 ops/sec [43,382..64,593] → 53,100 ops/sec [39,304..59,441]	~ overlap (+20.2%)
spread operator	55,456 ops/sec [55,277..57,576] → 51,814 ops/sec [51,236..52,464]	🔴 -6.6%	53,644 ops/sec [40,286..63,247] → 53,777 ops/sec [52,616..66,966]	~ overlap (+0.2%)

promises.js — Interp: 🟢 1, 11 unch. · avg -0.3% · Bytecode: 12 unch. · avg -2.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Promise.resolve(value)	82,974 ops/sec [67,933..101,958] → 70,372 ops/sec [69,820..70,531]	~ overlap (-15.2%)	76,109 ops/sec [74,309..78,407] → 75,986 ops/sec [71,995..93,569]	~ overlap (-0.2%)
new Promise(resolve => resolve(value))	49,769 ops/sec [49,488..64,582] → 50,472 ops/sec [50,069..50,674]	~ overlap (+1.4%)	57,504 ops/sec [56,412..78,404] → 57,511 ops/sec [57,187..57,888]	~ overlap (+0.0%)
Promise.reject(reason)	70,281 ops/sec [68,966..70,741] → 70,963 ops/sec [70,416..71,354]	~ overlap (+1.0%)	76,319 ops/sec [75,216..80,777] → 74,942 ops/sec [69,094..86,489]	~ overlap (-1.8%)
resolve + then (1 handler)	23,184 ops/sec [22,120..32,976] → 23,930 ops/sec [23,439..24,133]	~ overlap (+3.2%)	30,896 ops/sec [25,354..34,882] → 24,844 ops/sec [24,348..25,409]	~ overlap (-19.6%)
resolve + then chain (3 deep)	11,736 ops/sec [9,844..12,146] → 10,436 ops/sec [10,026..13,290]	~ overlap (-11.1%)	10,551 ops/sec [10,141..12,646] → 10,446 ops/sec [10,341..12,263]	~ overlap (-1.0%)
resolve + then chain (10 deep)	3,806 ops/sec [3,215..4,186] → 3,456 ops/sec [3,434..3,485]	~ overlap (-9.2%)	3,494 ops/sec [3,392..5,005] → 3,470 ops/sec [3,272..5,374]	~ overlap (-0.7%)
reject + catch + then	13,637 ops/sec [13,273..16,268] → 14,259 ops/sec [13,721..14,652]	~ overlap (+4.6%)	14,820 ops/sec [13,593..16,839] → 14,221 ops/sec [13,899..16,659]	~ overlap (-4.0%)
resolve + finally + then	6,441 ops/sec [6,390..6,498] → 7,447 ops/sec [6,737..9,844]	🟢 +15.6%	6,901 ops/sec [6,659..7,057] → 7,128 ops/sec [6,728..8,637]	~ overlap (+3.3%)
Promise.all (5 resolved)	4,582 ops/sec [4,416..7,045] → 4,770 ops/sec [4,506..4,918]	~ overlap (+4.1%)	4,703 ops/sec [4,656..4,823] → 4,683 ops/sec [4,477..5,761]	~ overlap (-0.4%)
Promise.race (5 resolved)	5,148 ops/sec [5,125..5,157] → 5,394 ops/sec [5,150..5,878]	~ overlap (+4.8%)	5,435 ops/sec [5,421..5,451] → 5,309 ops/sec [5,254..5,685]	~ overlap (-2.3%)
Promise.allSettled (5 mixed)	3,924 ops/sec [3,860..4,396] → 3,852 ops/sec [3,800..4,345]	~ overlap (-1.8%)	3,900 ops/sec [3,868..4,046] → 3,983 ops/sec [3,888..4,003]	~ overlap (+2.1%)
Promise.any (5 mixed)	4,673 ops/sec [4,509..6,334] → 4,626 ops/sec [4,597..5,797]	~ overlap (-1.0%)	4,730 ops/sec [4,612..5,744] → 4,702 ops/sec [4,532..5,557]	~ overlap (-0.6%)

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

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
class instance fields across 1000 instances	159 ops/sec [150..162] → 144 ops/sec [144..184]	~ overlap (-9.1%)	683 ops/sec [660..1,110] → 668 ops/sec [651..677]	~ overlap (-2.3%)
object literal fields across 1000 literals	156 ops/sec [149..170] → 181 ops/sec [180..182]	🟢 +16.0%	670 ops/sec [658..714] → 665 ops/sec [657..692]	~ overlap (-0.6%)
mixed-shape literals across 1000 literals	160 ops/sec [151..187] → 181 ops/sec [150..191]	~ overlap (+13.4%)	521 ops/sec [513..688] → 524 ops/sec [521..529]	~ overlap (+0.7%)
own-class method across 1000 instances	94 ops/sec [89..101] → 89 ops/sec [88..91]	~ overlap (-5.6%)	336 ops/sec [327..378] → 357 ops/sec [327..577]	~ overlap (+6.4%)
inherited method across 1000 instances	99 ops/sec [93..116] → 101 ops/sec [98..105]	~ overlap (+1.5%)	409 ops/sec [400..484] → 403 ops/sec [376..644]	~ overlap (-1.7%)

regexp.js — Interp: 11 unch. · avg +1.2% · Bytecode: 11 unch. · avg -0.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
regex literal creation	7,502 ops/sec [6,969..9,978] → 7,244 ops/sec [7,096..8,856]	~ overlap (-3.4%)	183,365 ops/sec [181,550..192,966] → 178,839 ops/sec [174,978..208,477]	~ overlap (-2.5%)
new RegExp(pattern, flags)	7,368 ops/sec [6,653..8,017] → 7,462 ops/sec [6,793..8,117]	~ overlap (+1.3%)	6,800 ops/sec [6,710..7,402] → 6,827 ops/sec [6,608..7,792]	~ overlap (+0.4%)
RegExp(existingRegex) returns the same regex	178,890 ops/sec [175,760..192,300] → 178,811 ops/sec [176,379..246,864]	~ overlap (-0.0%)	283,144 ops/sec [265,343..341,432] → 276,233 ops/sec [272,759..296,536]	~ overlap (-2.4%)
test() on a global regex	58,007 ops/sec [55,563..65,493] → 57,549 ops/sec [55,003..57,786]	~ overlap (-0.8%)	72,169 ops/sec [70,134..73,365] → 71,326 ops/sec [69,787..75,832]	~ overlap (-1.2%)
exec() with capture groups	15,890 ops/sec [15,764..17,084] → 15,787 ops/sec [15,445..18,355]	~ overlap (-0.6%)	16,261 ops/sec [16,127..16,696] → 17,319 ops/sec [16,487..17,435]	~ overlap (+6.5%)
toString()	155,699 ops/sec [153,799..157,008] → 158,674 ops/sec [154,322..168,170]	~ overlap (+1.9%)	224,802 ops/sec [218,142..232,955] → 228,563 ops/sec [225,329..229,077]	~ overlap (+1.7%)
match() with global regex	20,911 ops/sec [20,841..21,449] → 21,627 ops/sec [21,058..23,986]	~ overlap (+3.4%)	23,383 ops/sec [22,467..27,188] → 23,000 ops/sec [22,669..23,698]	~ overlap (-1.6%)
matchAll() with capture groups	10,215 ops/sec [9,852..10,305] → 10,300 ops/sec [9,758..12,384]	~ overlap (+0.8%)	14,122 ops/sec [14,038..14,165] → 14,055 ops/sec [13,557..14,272]	~ overlap (-0.5%)
replace() with global regex	18,980 ops/sec [18,465..19,116] → 21,617 ops/sec [17,896..23,324]	~ overlap (+13.9%)	20,559 ops/sec [19,700..23,653] → 20,000 ops/sec [19,796..20,222]	~ overlap (-2.7%)
search() with regex	40,558 ops/sec [38,798..45,744] → 39,286 ops/sec [38,063..39,903]	~ overlap (-3.1%)	47,192 ops/sec [46,405..53,779] → 47,381 ops/sec [46,713..47,830]	~ overlap (+0.4%)
split() with regex separator	7,476 ops/sec [7,390..7,548] → 7,481 ops/sec [7,367..7,655]	~ overlap (+0.1%)	7,490 ops/sec [7,455..7,543] → 7,513 ops/sec [7,364..7,906]	~ overlap (+0.3%)

strings.js — Interp: 🟢 5, 14 unch. · avg +2.3% · Bytecode: 🟢 2, 🔴 4, 13 unch. · avg -0.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
string concatenation	122,077 ops/sec [103,648..128,330] → 117,866 ops/sec [112,731..149,313]	~ overlap (-3.4%)	533,110 ops/sec [520,446..541,149] → 495,841 ops/sec [493,049..498,791]	🔴 -7.0%
template literal	190,814 ops/sec [181,672..199,502] → 206,638 ops/sec [204,708..208,465]	🟢 +8.3%	375,818 ops/sec [370,714..445,783] → 380,122 ops/sec [378,862..388,091]	~ overlap (+1.1%)
string repeat	128,973 ops/sec [127,490..130,038] → 138,153 ops/sec [136,830..151,578]	🟢 +7.1%	161,394 ops/sec [161,101..162,675] → 164,532 ops/sec [164,006..166,260]	🟢 +1.9%
split and join	54,997 ops/sec [46,154..58,682] → 49,022 ops/sec [47,935..55,298]	~ overlap (-10.9%)	54,589 ops/sec [49,558..58,474] → 56,345 ops/sec [55,859..61,491]	~ overlap (+3.2%)
indexOf and includes	52,167 ops/sec [50,563..52,545] → 54,676 ops/sec [53,123..55,037]	🟢 +4.8%	57,868 ops/sec [57,593..77,978] → 58,669 ops/sec [52,371..64,631]	~ overlap (+1.4%)
toUpperCase and toLowerCase	66,709 ops/sec [66,116..71,335] → 69,539 ops/sec [68,068..71,357]	~ overlap (+4.2%)	80,732 ops/sec [80,213..106,382] → 79,845 ops/sec [78,601..103,117]	~ overlap (-1.1%)
slice and substring	49,159 ops/sec [48,866..58,629] → 50,834 ops/sec [50,406..51,945]	~ overlap (+3.4%)	63,981 ops/sec [63,623..64,357] → 63,134 ops/sec [62,374..69,781]	~ overlap (-1.3%)
trim operations	57,279 ops/sec [54,026..64,158] → 60,563 ops/sec [58,600..69,346]	~ overlap (+5.7%)	73,576 ops/sec [73,063..78,494] → 72,786 ops/sec [70,194..75,432]	~ overlap (-1.1%)
replace and replaceAll	57,407 ops/sec [56,847..57,937] → 58,475 ops/sec [57,309..61,022]	~ overlap (+1.9%)	64,884 ops/sec [62,890..69,511] → 62,588 ops/sec [62,372..62,637]	🔴 -3.5%
startsWith and endsWith	43,331 ops/sec [42,317..47,035] → 42,807 ops/sec [42,297..43,250]	~ overlap (-1.2%)	47,624 ops/sec [47,424..47,666] → 46,140 ops/sec [45,911..46,220]	🔴 -3.1%
padStart and padEnd	68,257 ops/sec [66,198..69,118] → 67,643 ops/sec [67,256..98,107]	~ overlap (-0.9%)	76,205 ops/sec [75,610..79,671] → 77,558 ops/sec [71,435..79,841]	~ overlap (+1.8%)
identity tag, no substitutions	112,698 ops/sec [109,344..113,884] → 111,996 ops/sec [109,731..114,146]	~ overlap (-0.6%)	158,512 ops/sec [155,798..159,061] → 155,931 ops/sec [153,546..158,246]	~ overlap (-1.6%)
tag with 1 substitution	24,785 ops/sec [23,232..25,364] → 26,346 ops/sec [25,229..31,360]	~ overlap (+6.3%)	31,692 ops/sec [31,373..31,781] → 30,954 ops/sec [30,457..31,619]	~ overlap (-2.3%)
tag with 3 substitutions	13,773 ops/sec [13,617..13,846] → 14,706 ops/sec [14,060..15,781]	🟢 +6.8%	18,929 ops/sec [18,858..19,145] → 18,921 ops/sec [18,912..18,933]	~ overlap (-0.0%)
tag with 6 substitutions	8,111 ops/sec [7,796..8,188] → 8,462 ops/sec [8,096..8,650]	~ overlap (+4.3%)	11,716 ops/sec [11,498..12,832] → 11,370 ops/sec [11,200..11,409]	🔴 -3.0%
String.raw, no substitutions	89,215 ops/sec [84,066..91,138] → 89,372 ops/sec [88,786..89,513]	~ overlap (+0.2%)	87,163 ops/sec [85,424..96,546] → 88,427 ops/sec [86,591..103,287]	~ overlap (+1.4%)
String.raw, 2 substitutions	71,051 ops/sec [70,279..75,729] → 74,137 ops/sec [71,986..81,071]	~ overlap (+4.3%)	69,698 ops/sec [69,146..70,476] → 74,423 ops/sec [71,810..81,295]	🟢 +6.8%
tag accessing .raw array	42,769 ops/sec [40,386..44,709] → 42,421 ops/sec [40,708..48,337]	~ overlap (-0.8%)	45,391 ops/sec [44,963..45,637] → 45,651 ops/sec [45,417..46,117]	~ overlap (+0.6%)
method as tag (this binding)	16,486 ops/sec [16,175..16,733] → 17,181 ops/sec [16,845..19,312]	🟢 +4.2%	22,090 ops/sec [21,718..22,499] → 22,425 ops/sec [22,215..22,805]	~ overlap (+1.5%)

temporal.js — Interp: 🔴 1, 5 unch. · avg -7.3% · Bytecode: 🟢 1, 5 unch. · avg +1.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
PlainDate.add({ months: 1 })	42,182 ops/sec [41,295..44,574] → 41,190 ops/sec [39,835..42,909]	~ overlap (-2.3%)	45,378 ops/sec [39,222..52,930] → 43,370 ops/sec [42,982..43,772]	~ overlap (-4.4%)
PlainDate.until(..., { largestUnit: 'months' })	55,098 ops/sec [52,545..59,821] → 50,833 ops/sec [48,905..66,318]	~ overlap (-7.7%)	53,511 ops/sec [53,100..53,527] → 61,567 ops/sec [55,674..71,103]	🟢 +15.1%
Duration.total days relative to PlainDate	47,281 ops/sec [46,855..47,865] → 44,365 ops/sec [43,359..50,875]	~ overlap (-6.2%)	47,817 ops/sec [40,620..51,392] → 46,995 ops/sec [44,981..47,171]	~ overlap (-1.7%)
Duration.round to hours	34,178 ops/sec [32,937..36,773] → 31,936 ops/sec [31,478..33,563]	~ overlap (-6.6%)	33,094 ops/sec [32,743..34,390] → 33,276 ops/sec [32,607..38,732]	~ overlap (+0.6%)
ZonedDateTime.from named time zone	9,699 ops/sec [9,641..10,261] → 9,332 ops/sec [9,291..9,341]	🔴 -3.8%	9,996 ops/sec [9,887..10,201] → 9,888 ops/sec [9,808..9,916]	~ overlap (-1.1%)
ZonedDateTime.since across DST	11,049 ops/sec [9,483..11,386] → 9,135 ops/sec [9,094..10,340]	~ overlap (-17.3%)	10,195 ops/sec [9,967..10,419] → 10,044 ops/sec [9,804..11,444]	~ overlap (-1.5%)

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

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple 3-column TSV	41,291 ops/sec [40,087..41,462] → 41,770 ops/sec [40,412..42,056]	~ overlap (+1.2%)	43,904 ops/sec [43,303..44,898] → 44,463 ops/sec [43,588..47,915]	~ overlap (+1.3%)
parse 10-row TSV	11,169 ops/sec [11,036..11,558] → 11,529 ops/sec [11,290..12,009]	~ overlap (+3.2%)	11,595 ops/sec [11,312..12,084] → 11,683 ops/sec [11,632..12,244]	~ overlap (+0.8%)
parse 100-row TSV	1,849 ops/sec [1,753..2,037] → 1,870 ops/sec [1,863..1,884]	~ overlap (+1.1%)	2,178 ops/sec [1,822..2,412] → 1,942 ops/sec [1,851..2,114]	~ overlap (-10.9%)
parse TSV with backslash-escaped fields	8,991 ops/sec [8,478..10,129] → 8,741 ops/sec [8,692..9,530]	~ overlap (-2.8%)	8,818 ops/sec [8,591..10,575] → 8,756 ops/sec [8,613..8,977]	~ overlap (-0.7%)
parse without headers (array of arrays)	5,665 ops/sec [5,419..6,496] → 6,133 ops/sec [5,566..7,407]	~ overlap (+8.3%)	5,584 ops/sec [5,464..5,982] → 5,588 ops/sec [5,496..5,975]	~ overlap (+0.1%)
stringify array of objects	34,037 ops/sec [33,713..34,302] → 33,891 ops/sec [33,527..34,859]	~ overlap (-0.4%)	37,470 ops/sec [37,439..37,561] → 37,834 ops/sec [37,263..40,460]	~ overlap (+1.0%)
stringify array of arrays	10,327 ops/sec [10,194..11,247] → 10,335 ops/sec [9,950..11,282]	~ overlap (+0.1%)	10,985 ops/sec [10,696..11,067] → 11,211 ops/sec [10,790..11,988]	~ overlap (+2.1%)
stringify with values needing escaping	28,500 ops/sec [28,286..28,576] → 28,006 ops/sec [27,804..30,794]	~ overlap (-1.7%)	33,258 ops/sec [29,937..33,743] → 30,792 ops/sec [30,012..32,537]	~ overlap (-7.4%)
parse then stringify	6,158 ops/sec [6,108..6,355] → 6,409 ops/sec [6,360..6,495]	🟢 +4.1%	6,797 ops/sec [6,770..6,854] → 6,713 ops/sec [6,505..9,623]	~ overlap (-1.2%)

typed-arrays.js — Interp: 🟢 9, 13 unch. · avg +39.9% · Bytecode: 🟢 3, 🔴 4, 15 unch. · avg +2.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
new Int32Array(0)	104,138 ops/sec [92,937..107,410] → 92,352 ops/sec [91,610..94,577]	~ overlap (-11.3%)	119,405 ops/sec [105,971..143,844] → 108,400 ops/sec [107,607..109,500]	~ overlap (-9.2%)
new Int32Array(100)	91,297 ops/sec [89,383..91,657] → 90,247 ops/sec [89,808..102,943]	~ overlap (-1.1%)	103,996 ops/sec [99,577..137,073] → 108,663 ops/sec [107,910..115,955]	~ overlap (+4.5%)
new Int32Array(1000)	74,195 ops/sec [71,159..89,198] → 77,396 ops/sec [76,587..80,575]	~ overlap (+4.3%)	83,548 ops/sec [78,208..108,919] → 82,963 ops/sec [79,200..87,403]	~ overlap (-0.7%)
new Float64Array(100)	89,563 ops/sec [79,802..97,510] → 88,132 ops/sec [87,373..88,992]	~ overlap (-1.6%)	99,866 ops/sec [97,699..100,536] → 99,755 ops/sec [98,392..100,646]	~ overlap (-0.1%)
Int32Array.from([...])	1,461 ops/sec [1,392..1,590] → 1,500 ops/sec [1,473..1,630]	~ overlap (+2.7%)	1,547 ops/sec [1,503..2,010] → 1,452 ops/sec [1,441..1,796]	~ overlap (-6.1%)
Int32Array.of(1, 2, 3, 4, 5)	65,588 ops/sec [64,562..67,345] → 71,549 ops/sec [66,380..96,558]	~ overlap (+9.1%)	80,796 ops/sec [80,203..81,232] → 79,855 ops/sec [79,213..80,267]	~ overlap (-1.2%)
sequential write 100 elements	1,101 ops/sec [1,090..1,104] → 1,096 ops/sec [1,061..1,103]	~ overlap (-0.4%)	5,148 ops/sec [5,088..5,194] → 5,056 ops/sec [4,995..5,107]	~ overlap (-1.8%)
sequential read 100 elements	1,190 ops/sec [1,054..1,196] → 1,149 ops/sec [1,147..1,155]	~ overlap (-3.4%)	6,492 ops/sec [6,383..6,592] → 6,657 ops/sec [6,595..6,728]	🟢 +2.5%
Float64Array write 100 elements	1,077 ops/sec [1,024..1,108] → 1,062 ops/sec [1,044..1,386]	~ overlap (-1.3%)	4,131 ops/sec [4,057..4,185] → 4,239 ops/sec [4,204..4,277]	🟢 +2.6%
fill(42)	1,911 ops/sec [1,899..1,914] → 1,910 ops/sec [1,840..1,928]	~ overlap (-0.1%)	2,245 ops/sec [2,171..2,251] → 2,169 ops/sec [2,128..2,196]	~ overlap (-3.4%)
slice()	7,882 ops/sec [7,785..8,170] → 8,308 ops/sec [7,977..8,832]	~ overlap (+5.4%)	8,846 ops/sec [8,805..9,149] → 8,884 ops/sec [8,793..8,943]	~ overlap (+0.4%)
map(x => x * 2)	2,149 ops/sec [2,097..2,262] → 3,747 ops/sec [3,661..3,772]	🟢 +74.3%	2,189 ops/sec [2,140..3,606] → 3,518 ops/sec [3,503..3,529]	~ overlap (+60.7%)
filter(x => x > 50)	2,240 ops/sec [2,208..2,417] → 3,935 ops/sec [3,864..3,951]	🟢 +75.7%	2,355 ops/sec [2,314..3,905] → 3,824 ops/sec [3,796..3,836]	~ overlap (+62.4%)
reduce (sum)	2,362 ops/sec [2,159..3,227] → 3,983 ops/sec [2,188..4,016]	~ overlap (+68.6%)	3,691 ops/sec [3,671..3,718] → 3,602 ops/sec [3,565..3,637]	🔴 -2.4%
sort()	11,884 ops/sec [11,814..11,972] → 24,787 ops/sec [24,695..25,013]	🟢 +108.6%	23,930 ops/sec [23,792..24,050] → 13,810 ops/sec [13,485..23,997]	~ overlap (-42.3%)
indexOf()	28,160 ops/sec [27,422..28,276] → 53,379 ops/sec [52,951..53,703]	🟢 +89.6%	51,778 ops/sec [50,076..52,007] → 30,086 ops/sec [29,782..30,504]	🔴 -41.9%
reverse()	13,462 ops/sec [13,093..15,282] → 27,719 ops/sec [15,424..27,966]	🟢 +105.9%	27,074 ops/sec [26,859..27,223] → 15,212 ops/sec [15,024..15,292]	🔴 -43.8%
create view over existing buffer	118,377 ops/sec [102,216..123,125] → 182,564 ops/sec [181,744..183,366]	🟢 +54.2%	200,723 ops/sec [198,555..202,451] → 199,270 ops/sec [197,972..200,739]	~ overlap (-0.7%)
subarray()	68,273 ops/sec [67,249..79,827] → 122,368 ops/sec [120,096..123,546]	🟢 +79.2%	122,994 ops/sec [122,692..123,152] → 120,663 ops/sec [120,537..121,080]	🔴 -1.9%
set() from array	74,171 ops/sec [73,625..81,407] → 136,429 ops/sec [133,917..137,684]	🟢 +83.9%	156,321 ops/sec [155,819..156,739] → 154,649 ops/sec [152,219..155,986]	~ overlap (-1.1%)
for-of loop	1,749 ops/sec [1,578..1,781] → 2,736 ops/sec [1,640..2,755]	~ overlap (+56.4%)	7,650 ops/sec [7,495..12,737] → 12,912 ops/sec [12,758..12,946]	🟢 +68.8%
spread into array	6,339 ops/sec [6,134..6,567] → 11,304 ops/sec [10,586..11,441]	🟢 +78.3%	39,120 ops/sec [38,733..39,489] → 39,596 ops/sec [39,420..39,743]	~ overlap (+1.2%)

uint8array-encoding.js — Interp: 🔴 5, 13 unch. · avg -12.4% · Bytecode: 🟢 3, 🔴 1, 14 unch. · avg +10.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
short (5 bytes)	146,398 ops/sec [136,468..158,504] → 141,049 ops/sec [136,740..168,209]	~ overlap (-3.7%)	182,490 ops/sec [178,038..184,834] → 184,172 ops/sec [179,138..187,331]	~ overlap (+0.9%)
medium (450 bytes)	103,130 ops/sec [99,483..119,664] → 99,929 ops/sec [99,373..100,855]	~ overlap (-3.1%)	117,506 ops/sec [116,753..118,153] → 118,261 ops/sec [117,566..119,879]	~ overlap (+0.6%)
large (4096 bytes)	30,237 ops/sec [29,710..31,262] → 29,514 ops/sec [29,022..29,991]	~ overlap (-2.4%)	30,589 ops/sec [30,122..31,669] → 30,189 ops/sec [29,411..30,638]	~ overlap (-1.3%)
base64url alphabet	77,545 ops/sec [75,113..86,969] → 75,916 ops/sec [74,387..86,610]	~ overlap (-2.1%)	80,547 ops/sec [80,058..81,090] → 80,150 ops/sec [79,364..80,284]	~ overlap (-0.5%)
omitPadding	103,648 ops/sec [97,964..108,252] → 99,551 ops/sec [97,338..100,809]	~ overlap (-4.0%)	111,283 ops/sec [110,260..120,545] → 109,433 ops/sec [105,783..114,217]	~ overlap (-1.7%)
short (8 chars)	116,653 ops/sec [112,495..135,189] → 111,771 ops/sec [109,309..113,418]	~ overlap (-4.2%)	134,428 ops/sec [133,162..147,529] → 132,226 ops/sec [131,135..135,634]	~ overlap (-1.6%)
medium (600 chars)	60,747 ops/sec [58,662..64,747] → 61,619 ops/sec [61,152..61,717]	~ overlap (+1.4%)	66,182 ops/sec [65,311..66,753] → 65,802 ops/sec [65,453..66,890]	~ overlap (-0.6%)
large (5464 chars)	13,082 ops/sec [12,638..13,563] → 13,264 ops/sec [13,209..13,658]	~ overlap (+1.4%)	13,045 ops/sec [12,990..15,023] → 13,230 ops/sec [13,072..13,362]	~ overlap (+1.4%)
short (5 bytes)	148,144 ops/sec [143,952..159,898] → 149,616 ops/sec [145,031..250,222]	~ overlap (+1.0%)	199,617 ops/sec [197,009..334,382] → 197,340 ops/sec [194,453..209,788]	~ overlap (-1.1%)
medium (450 bytes)	94,588 ops/sec [92,317..95,862] → 95,781 ops/sec [91,036..156,481]	~ overlap (+1.3%)	178,485 ops/sec [178,263..178,550] → 113,377 ops/sec [105,398..125,390]	🔴 -36.5%
large (4096 bytes)	40,952 ops/sec [40,487..41,187] → 23,200 ops/sec [23,059..23,331]	🔴 -43.3%	23,185 ops/sec [22,394..23,477] → 22,601 ops/sec [22,134..22,943]	~ overlap (-2.5%)
short (10 chars)	208,362 ops/sec [206,498..210,067] → 123,793 ops/sec [123,143..206,154]	🔴 -40.6%	147,924 ops/sec [147,255..148,782] → 233,676 ops/sec [217,194..234,303]	🟢 +58.0%
medium (900 chars)	158,839 ops/sec [154,486..159,871] → 107,171 ops/sec [92,725..108,108]	🔴 -32.5%	102,319 ops/sec [100,192..103,649] → 168,763 ops/sec [168,236..169,274]	🟢 +64.9%
large (8192 chars)	52,611 ops/sec [52,240..52,842] → 28,461 ops/sec [28,191..29,675]	🔴 -45.9%	28,004 ops/sec [27,053..29,123] → 50,920 ops/sec [50,162..51,073]	🟢 +81.8%
setFromBase64 (450 bytes)	54,830 ops/sec [54,469..61,502] → 54,676 ops/sec [54,062..54,958]	~ overlap (-0.3%)	62,824 ops/sec [57,220..70,443] → 97,619 ops/sec [58,041..98,100]	~ overlap (+55.4%)
setFromHex (450 bytes)	18,958 ops/sec [17,432..33,563] → 17,853 ops/sec [17,374..23,524]	~ overlap (-5.8%)	21,411 ops/sec [21,309..21,777] → 21,375 ops/sec [21,108..22,170]	~ overlap (-0.2%)
toBase64 → fromBase64 (450 bytes)	73,002 ops/sec [72,077..73,585] → 43,723 ops/sec [43,475..44,410]	🔴 -40.1%	75,498 ops/sec [46,239..76,561] → 49,291 ops/sec [46,507..51,185]	~ overlap (-34.7%)
toHex → fromHex (450 bytes)	92,108 ops/sec [91,257..92,889] → 91,569 ops/sec [90,338..92,387]	~ overlap (-0.6%)	97,221 ops/sec [95,325..98,103] → 96,499 ops/sec [65,242..97,608]	~ overlap (-0.7%)

weak-collections.js — Interp: 🟢 2, 🔴 1, 12 unch. · avg -3.3% · Bytecode: 🟢 4, 🔴 4, 7 unch. · avg -7.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
constructor from 50 entries	9,640 ops/sec [9,152..9,896] → 9,806 ops/sec [9,642..10,845]	~ overlap (+1.7%)	10,345 ops/sec [10,135..10,464] → 9,661 ops/sec [9,578..9,954]	🔴 -6.6%
set 50 object keys	3,015 ops/sec [3,011..3,020] → 3,060 ops/sec [2,900..3,466]	~ overlap (+1.5%)	3,917 ops/sec [3,879..3,932] → 4,142 ops/sec [3,796..4,650]	~ overlap (+5.7%)
get lookups (50 entries)	43,951 ops/sec [43,935..44,567] → 46,065 ops/sec [45,484..48,356]	🟢 +4.8%	77,758 ops/sec [77,252..79,691] → 78,876 ops/sec [77,203..83,753]	~ overlap (+1.4%)
has checks (50 entries)	57,793 ops/sec [56,883..59,713] → 59,080 ops/sec [57,449..60,066]	~ overlap (+2.2%)	101,673 ops/sec [99,304..102,465] → 99,479 ops/sec [97,104..100,965]	~ overlap (-2.2%)
delete entries	2,778 ops/sec [2,718..2,882] → 2,789 ops/sec [2,721..2,931]	~ overlap (+0.4%)	3,652 ops/sec [3,625..3,739] → 3,706 ops/sec [3,661..3,720]	~ overlap (+1.5%)
non-registered symbol keys	6,861 ops/sec [6,794..6,955] → 6,980 ops/sec [6,735..7,500]	~ overlap (+1.7%)	8,810 ops/sec [8,791..8,889] → 9,064 ops/sec [8,917..9,125]	🟢 +2.9%
getOrInsert	2,806 ops/sec [2,776..3,328] → 2,963 ops/sec [2,953..2,982]	~ overlap (+5.6%)	3,380 ops/sec [3,340..3,430] → 3,587 ops/sec [3,537..4,001]	🟢 +6.1%
getOrInsertComputed	1,643 ops/sec [1,626..1,671] → 1,678 ops/sec [1,662..1,744]	~ overlap (+2.1%)	1,786 ops/sec [1,782..1,793] → 1,832 ops/sec [1,817..1,843]	🟢 +2.6%
forced gc live-key retention	115 ops/sec [106..122] → 116 ops/sec [90..127]	~ overlap (+0.5%)	81 ops/sec [71..102] → 72 ops/sec [68..91]	~ overlap (-10.9%)
constructor from 50 values	22,453 ops/sec [11,786..23,397] → 12,128 ops/sec [11,972..12,405]	~ overlap (-46.0%)	12,745 ops/sec [12,600..13,055] → 12,130 ops/sec [11,719..12,336]	🔴 -4.8%
add 50 object values	5,453 ops/sec [5,419..5,501] → 3,237 ops/sec [3,190..3,256]	🔴 -40.6%	4,092 ops/sec [4,077..4,129] → 4,171 ops/sec [4,146..4,206]	🟢 +1.9%
has checks (50 values)	100,709 ops/sec [56,639..101,733] → 64,795 ops/sec [64,241..65,654]	~ overlap (-35.7%)	101,601 ops/sec [100,509..103,926] → 100,342 ops/sec [100,101..100,856]	~ overlap (-1.2%)
delete values	10,021 ops/sec [9,255..10,617] → 17,223 ops/sec [17,016..17,299]	🟢 +71.9%	10,923 ops/sec [10,768..17,027] → 10,802 ops/sec [10,458..11,133]	~ overlap (-1.1%)
non-registered symbol values	12,385 ops/sec [12,201..12,571] → 12,356 ops/sec [7,273..12,694]	~ overlap (-0.2%)	15,822 ops/sec [15,784..15,866] → 9,677 ops/sec [9,416..9,752]	🔴 -38.8%
forced gc pruning smoke	285 ops/sec [280..285] → 229 ops/sec [223..285]	~ overlap (-19.6%)	204 ops/sec [182..207] → 72 ops/sec [67..77]	🔴 -64.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: 11,046 passed; bytecode: 11,046 passed)

Metric	Interpreted	Bytecode
Total	11046	11046
Passed	11046 ✅	11046 ✅
Workers	4	4
Test Duration	18.74s	17.53s
Lex (cumulative)	496.4ms	477.3ms
Parse (cumulative)	378.7ms	350.8ms
Compile (cumulative)	—	709.2ms
Execute (cumulative)	74.4ms	41.47s
Engine Total (cumulative)	949.5ms	43.00s
Lex (avg/worker)	124.1ms	119.3ms
Parse (avg/worker)	94.7ms	87.7ms
Compile (avg/worker)	—	177.3ms
Execute (avg/worker)	18.6ms	10.37s
Engine Total (avg/worker)	237.4ms	10.75s

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	283.78 MiB	281.18 MiB
GC Peak Live	332.46 MiB	315.20 MiB
GC Allocated During Run	531.00 MiB	474.99 MiB
GC Limit	7.81 GiB	7.81 GiB
GC Collections	195	195
GC Collected Objects	2,605,579	2,172,695
Heap Start Allocated	182.6 KiB	182.6 KiB
Heap End Allocated	3.66 MiB	3.66 MiB
Heap Delta Allocated	3.48 MiB	3.48 MiB
Heap Delta Free	1.68 MiB	1.68 MiB

Benchmarks (interpreted: 437; bytecode: 437)

Metric	Interpreted	Bytecode
Total	437	437
Workers	4	4
Duration	2.79min	2.73min

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	6.28 MiB	6.28 MiB
GC Peak Live	97.83 MiB	66.78 MiB
GC Allocated During Run	15.79 GiB	9.60 GiB
GC Limit	7.81 GiB	7.81 GiB
GC Collections	3,865	3,430
GC Collected Objects	250,758,322	221,427,179
Heap Start Allocated	3.36 MiB	3.36 MiB
Heap End Allocated	3.36 MiB	3.36 MiB
Heap Delta Allocated	128 B	128 B

_{Measured on ubuntu-latest x64.}

[github-actions]

test262 Conformance

🚫 Regression vs cached main baseline. 1 previously-passing test(s) now fail; pass count Δ +0. This run blocks merge — see "Newly failing" below.

Category	Run	Passed	Δ Pass	Failed	Pass-rate	Δ Rate
built-ins	23,643	22,619	+1	1,024	95.7%	±0pp
harness	116	116	±0	0	100.0%	±0pp
intl402	3,341	3,334	-1	7	99.8%	±0pp
language	23,711	23,711	±0	0	100.0%	±0pp
staging	1,482	1,111	±0	371	75.0%	±0pp
total	52,293	50,891	±0	1,402	97.3%	±0pp

Areas closest to 100%

Area	Pass rate	Δ vs main	Passing
built-ins/TypedArray	99.9%	±0pp	1,445 / 1,446
intl402/Temporal	99.9%	±0pp	2,026 / 2,029
built-ins/Object	99.7%	±0pp	3,401 / 3,411

Per-test deltas (+1 / -1)

Newly failing (1):

• intl402/DateTimeFormat/prototype/formatToParts/compare-to-temporal.js

Newly passing (1):

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

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