chore(toml-test): bump pin to 4d77658d

[github-actions]

Automated bump of the toml-test SHA pin to 4d77658d0f903a13454ece4dbfeafeb7c7f31c9f.

CI will run the TOML compliance suite against the new SHA.
Review the delta and merge if acceptable.

Cron: weekly, Mondays 06:30 UTC. See .github/workflows/toml-test-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 8:16am

[github-actions]

Benchmark Results

437 benchmarks · PR vs same-runner main build

Interpreted: 🟢 19 improved · 🔴 53 regressed · 365 unchanged · avg -0.5%
Bytecode: 🟢 36 improved · 🔴 41 regressed · 360 unchanged · avg +0.6%

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

arraybuffer.js — Interp: 🟢 2, 🔴 1, 11 unch. · avg +0.4% · Bytecode: 🟢 2, 12 unch. · avg -0.6%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
create ArrayBuffer(0)	117,988 ops/sec [115,918..119,605] → 113,666 ops/sec [104,562..118,617]	~ overlap (-3.7%)	148,049 ops/sec [145,857..169,080] → 147,910 ops/sec [119,929..217,362]	~ overlap (-0.1%)
create ArrayBuffer(64)	122,239 ops/sec [114,327..154,910] → 113,323 ops/sec [111,266..114,262]	🔴 -7.3%	148,046 ops/sec [146,396..148,672] → 147,124 ops/sec [142,200..175,740]	~ overlap (-0.6%)
create ArrayBuffer(1024)	106,688 ops/sec [102,480..112,028] → 104,563 ops/sec [98,513..112,750]	~ overlap (-2.0%)	130,182 ops/sec [110,274..131,197] → 128,238 ops/sec [126,387..139,409]	~ overlap (-1.5%)
create ArrayBuffer(8192)	73,245 ops/sec [51,234..75,053] → 77,439 ops/sec [77,180..77,851]	🟢 +5.7%	74,703 ops/sec [74,102..81,295] → 74,950 ops/sec [74,202..76,288]	~ overlap (+0.3%)
slice full buffer (64 bytes)	97,741 ops/sec [97,345..103,087] → 104,583 ops/sec [97,928..122,347]	~ overlap (+7.0%)	118,789 ops/sec [116,764..119,105] → 117,238 ops/sec [115,339..118,407]	~ overlap (-1.3%)
slice half buffer (512 of 1024 bytes)	89,797 ops/sec [87,735..95,526] → 93,984 ops/sec [90,629..96,475]	~ overlap (+4.7%)	112,091 ops/sec [109,384..123,452] → 110,410 ops/sec [109,873..111,024]	~ overlap (-1.5%)
slice with negative indices	83,171 ops/sec [81,564..90,554] → 93,007 ops/sec [84,589..109,634]	~ overlap (+11.8%)	113,378 ops/sec [111,104..113,728] → 115,254 ops/sec [114,127..115,504]	🟢 +1.7%
slice empty range	93,538 ops/sec [92,949..93,842] → 96,009 ops/sec [94,890..98,805]	🟢 +2.6%	117,392 ops/sec [116,424..128,788] → 117,402 ops/sec [114,128..118,912]	~ overlap (+0.0%)
byteLength access	291,581 ops/sec [261,200..326,287] → 281,427 ops/sec [278,440..285,932]	~ overlap (-3.5%)	335,977 ops/sec [334,259..337,072] → 326,290 ops/sec [323,630..335,080]	~ overlap (-2.9%)
Symbol.toStringTag access	234,104 ops/sec [217,065..258,573] → 226,052 ops/sec [215,045..247,977]	~ overlap (-3.4%)	244,681 ops/sec [233,883..261,043] → 236,343 ops/sec [232,978..256,285]	~ overlap (-3.4%)
ArrayBuffer.isView	169,860 ops/sec [169,514..171,658] → 173,585 ops/sec [170,806..184,742]	~ overlap (+2.2%)	238,983 ops/sec [228,457..240,385] → 227,325 ops/sec [224,521..229,275]	~ overlap (-4.9%)
clone ArrayBuffer(64)	134,011 ops/sec [126,213..144,103] → 126,813 ops/sec [124,946..139,031]	~ overlap (-5.4%)	168,482 ops/sec [164,149..210,409] → 174,006 ops/sec [169,706..178,072]	~ overlap (+3.3%)
clone ArrayBuffer(1024)	114,155 ops/sec [112,086..115,457] → 111,590 ops/sec [110,082..114,378]	~ overlap (-2.2%)	142,706 ops/sec [139,906..144,681] → 148,093 ops/sec [145,628..161,809]	🟢 +3.8%
clone ArrayBuffer inside object	85,358 ops/sec [83,277..96,682] → 84,569 ops/sec [82,113..95,690]	~ overlap (-0.9%)	105,367 ops/sec [99,254..123,771] → 103,439 ops/sec [99,150..117,568]	~ overlap (-1.8%)

arrays.js — Interp: 🔴 2, 17 unch. · avg -1.3% · Bytecode: 🟢 3, 🔴 1, 15 unch. · avg +1.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Array.from length 100	3,360 ops/sec [3,196..3,541] → 3,171 ops/sec [3,071..3,593]	~ overlap (-5.6%)	3,086 ops/sec [2,950..3,788] → 3,195 ops/sec [2,928..3,416]	~ overlap (+3.5%)
Array.from 10 elements	65,832 ops/sec [64,074..67,022] → 66,306 ops/sec [63,824..77,312]	~ overlap (+0.7%)	81,219 ops/sec [74,198..94,703] → 74,259 ops/sec [73,401..75,004]	~ overlap (-8.6%)
Array.of 10 elements	83,912 ops/sec [80,647..98,218] → 83,599 ops/sec [81,395..102,722]	~ overlap (-0.4%)	106,340 ops/sec [95,752..164,293] → 107,380 ops/sec [106,203..108,750]	~ overlap (+1.0%)
spread into new array	94,397 ops/sec [92,391..96,489] → 92,968 ops/sec [91,032..93,805]	~ overlap (-1.5%)	54,776 ops/sec [52,464..69,538] → 53,639 ops/sec [53,111..55,422]	~ overlap (-2.1%)
map over 50 elements	5,106 ops/sec [5,070..5,158] → 5,043 ops/sec [4,931..5,333]	~ overlap (-1.2%)	5,843 ops/sec [5,793..6,250] → 5,997 ops/sec [5,866..6,460]	~ overlap (+2.6%)
filter over 50 elements	4,862 ops/sec [4,857..4,871] → 4,651 ops/sec [4,600..4,948]	~ overlap (-4.3%)	5,740 ops/sec [5,593..5,769] → 5,557 ops/sec [5,490..5,643]	~ overlap (-3.2%)
reduce sum 50 elements	5,381 ops/sec [5,336..5,942] → 5,810 ops/sec [5,193..6,333]	~ overlap (+8.0%)	5,515 ops/sec [5,433..5,592] → 5,779 ops/sec [5,038..5,935]	~ overlap (+4.8%)
forEach over 50 elements	3,685 ops/sec [3,623..4,075] → 3,635 ops/sec [3,612..3,681]	~ overlap (-1.4%)	5,887 ops/sec [5,819..5,905] → 5,973 ops/sec [5,945..6,000]	🟢 +1.5%
find in 50 elements	7,175 ops/sec [7,096..7,206] → 7,248 ops/sec [6,998..8,278]	~ overlap (+1.0%)	7,424 ops/sec [7,126..8,007] → 7,665 ops/sec [7,639..7,682]	~ overlap (+3.3%)
sort 20 elements	4,500 ops/sec [4,437..4,906] → 4,776 ops/sec [4,317..5,158]	~ overlap (+6.1%)	4,939 ops/sec [4,931..4,973] → 4,929 ops/sec [4,891..5,930]	~ overlap (-0.2%)
flat nested array	40,367 ops/sec [39,747..46,659] → 39,596 ops/sec [38,522..54,288]	~ overlap (-1.9%)	44,409 ops/sec [43,887..50,934] → 43,885 ops/sec [42,801..44,991]	~ overlap (-1.2%)
flatMap	21,619 ops/sec [21,460..30,186] → 20,669 ops/sec [20,438..21,013]	🔴 -4.4%	23,737 ops/sec [23,506..26,845] → 23,364 ops/sec [22,728..23,491]	🔴 -1.6%
map inside map (5x5)	5,623 ops/sec [5,605..5,647] → 5,565 ops/sec [5,493..6,052]	~ overlap (-1.0%)	6,164 ops/sec [6,121..6,244] → 6,590 ops/sec [6,011..6,940]	~ overlap (+6.9%)
filter inside map (5x10)	3,817 ops/sec [3,796..4,738] → 3,786 ops/sec [3,705..3,821]	~ overlap (-0.8%)	4,262 ops/sec [4,238..4,560] → 4,350 ops/sec [4,260..4,525]	~ overlap (+2.1%)
reduce inside map (5x10)	4,365 ops/sec [4,319..5,471] → 4,234 ops/sec [4,193..5,790]	~ overlap (-3.0%)	4,482 ops/sec [4,437..4,604] → 4,644 ops/sec [4,609..4,671]	🟢 +3.6%
forEach inside forEach (5x10)	3,074 ops/sec [3,053..3,203] → 3,071 ops/sec [2,988..3,096]	~ overlap (-0.1%)	4,879 ops/sec [4,760..4,980] → 5,042 ops/sec [5,002..5,086]	🟢 +3.3%
find inside some (10x10)	3,238 ops/sec [3,203..3,285] → 3,115 ops/sec [3,015..3,135]	🔴 -3.8%	3,569 ops/sec [3,554..3,586] → 3,621 ops/sec [3,542..3,821]	~ overlap (+1.5%)
map+filter chain nested (5x20)	1,189 ops/sec [1,186..1,446] → 1,219 ops/sec [1,155..1,430]	~ overlap (+2.5%)	1,351 ops/sec [1,346..1,372] → 1,387 ops/sec [1,339..1,561]	~ overlap (+2.6%)
reduce flatten (10x5)	11,260 ops/sec [10,098..12,350] → 9,794 ops/sec [9,713..10,248]	~ overlap (-13.0%)	4,221 ops/sec [4,153..4,435] → 4,256 ops/sec [4,180..4,281]	~ overlap (+0.8%)

async-await.js — Interp: 6 unch. · avg -1.5% · Bytecode: 🔴 2, 4 unch. · avg -0.6%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
single await	23,108 ops/sec [22,514..26,571] → 22,260 ops/sec [19,232..23,333]	~ overlap (-3.7%)	23,478 ops/sec [22,984..24,066] → 23,644 ops/sec [22,882..23,912]	~ overlap (+0.7%)
multiple awaits	9,446 ops/sec [9,213..10,233] → 9,211 ops/sec [8,962..10,371]	~ overlap (-2.5%)	8,428 ops/sec [8,368..10,666] → 8,395 ops/sec [8,086..9,396]	~ overlap (-0.4%)
await non-Promise value	30,723 ops/sec [29,798..31,006] → 30,907 ops/sec [28,868..32,047]	~ overlap (+0.6%)	31,534 ops/sec [30,615..32,757] → 29,941 ops/sec [29,148..30,605]	🔴 -5.1%
await with try/catch	20,017 ops/sec [19,756..22,939] → 19,500 ops/sec [19,220..19,875]	~ overlap (-2.6%)	22,591 ops/sec [21,897..23,475] → 22,889 ops/sec [22,066..23,658]	~ overlap (+1.3%)
await Promise.all	5,442 ops/sec [5,344..5,495] → 5,273 ops/sec [5,111..5,534]	~ overlap (-3.1%)	5,882 ops/sec [5,808..5,988] → 5,533 ops/sec [5,493..5,577]	🔴 -5.9%
nested async function call	13,073 ops/sec [12,288..13,684] → 13,339 ops/sec [12,615..14,322]	~ overlap (+2.0%)	12,942 ops/sec [12,587..13,636] → 13,706 ops/sec [12,210..14,562]	~ overlap (+5.9%)

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

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for-await-of over async generator	1,742 ops/sec [1,512..1,909] → 1,664 ops/sec [1,506..1,856]	~ overlap (-4.4%)	607 ops/sec [588..704] → 563 ops/sec [494..600]	~ overlap (-7.2%)
async generator with await in body	10,867 ops/sec [10,437..11,256] → 10,926 ops/sec [10,395..11,182]	~ overlap (+0.5%)	4,357 ops/sec [3,662..4,934] → 4,409 ops/sec [4,288..4,798]	~ overlap (+1.2%)

atomics.js — Interp: 6 unch. · avg -1.4% · Bytecode: 🔴 1, 5 unch. · avg -0.7%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
load and store Int32Array	80,648 ops/sec [78,343..82,028] → 78,143 ops/sec [77,752..81,902]	~ overlap (-3.1%)	125,600 ops/sec [124,298..129,437] → 127,243 ops/sec [123,591..155,884]	~ overlap (+1.3%)
read-modify-write Int32Array	54,107 ops/sec [53,047..54,516] → 55,184 ops/sec [54,296..55,632]	~ overlap (+2.0%)	85,453 ops/sec [83,428..92,747] → 84,402 ops/sec [82,105..96,308]	~ overlap (-1.2%)
compareExchange hit and miss	49,869 ops/sec [49,687..50,202] → 49,375 ops/sec [49,133..51,928]	~ overlap (-1.0%)	77,901 ops/sec [72,569..85,525] → 75,123 ops/sec [74,356..75,428]	~ overlap (-3.6%)
wait with zero timeout	131,375 ops/sec [128,996..138,657] → 133,891 ops/sec [123,388..142,256]	~ overlap (+1.9%)	195,626 ops/sec [194,310..195,944] → 198,367 ops/sec [189,620..213,685]	~ overlap (+1.4%)
waitAsync synchronous not-equal	94,772 ops/sec [92,850..95,885] → 93,883 ops/sec [88,893..94,036]	~ overlap (-0.9%)	126,503 ops/sec [126,133..127,745] → 126,055 ops/sec [125,401..126,488]	~ overlap (-0.4%)
notify with no waiters	145,083 ops/sec [135,541..151,274] → 134,686 ops/sec [133,393..136,582]	~ overlap (-7.2%)	200,899 ops/sec [199,410..201,944] → 197,467 ops/sec [196,625..198,365]	🔴 -1.7%

base64.js — Interp: 🔴 3, 7 unch. · avg -0.5% · Bytecode: 🔴 2, 8 unch. · avg -0.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
short ASCII (13 chars)	2,400 ops/sec [2,346..2,542] → 2,367 ops/sec [2,348..2,508]	~ overlap (-1.4%)	2,471 ops/sec [2,445..2,484] → 2,439 ops/sec [2,429..2,456]	~ overlap (-1.3%)
medium ASCII (450 chars)	88 ops/sec [86..88] → 85 ops/sec [85..85]	🔴 -2.8%	89 ops/sec [89..102] → 89 ops/sec [88..89]	~ overlap (-0.9%)
Latin-1 characters	3,546 ops/sec [3,495..3,746] → 3,443 ops/sec [3,326..3,473]	🔴 -2.9%	3,552 ops/sec [3,538..3,582] → 3,540 ops/sec [3,507..3,561]	~ overlap (-0.3%)
short base64 (20 chars)	1,714 ops/sec [1,698..1,722] → 1,707 ops/sec [1,670..1,726]	~ overlap (-0.4%)	1,740 ops/sec [1,700..1,759] → 1,740 ops/sec [1,722..1,765]	~ overlap (+0.0%)
medium base64 (600 chars)	68 ops/sec [67..68] → 68 ops/sec [67..68]	~ overlap (+0.1%)	67 ops/sec [67..68] → 68 ops/sec [67..68]	~ overlap (+1.5%)
Latin-1 output	2,442 ops/sec [2,432..2,452] → 2,607 ops/sec [2,432..2,775]	~ overlap (+6.8%)	2,441 ops/sec [2,362..2,786] → 2,476 ops/sec [2,449..2,498]	~ overlap (+1.4%)
forgiving (no padding)	3,716 ops/sec [3,556..4,552] → 3,686 ops/sec [3,663..3,714]	~ overlap (-0.8%)	4,006 ops/sec [3,944..4,037] → 3,676 ops/sec [3,645..3,707]	🔴 -8.2%
with whitespace	1,640 ops/sec [1,588..1,653] → 1,637 ops/sec [1,597..1,840]	~ overlap (-0.2%)	1,635 ops/sec [1,628..1,744] → 1,609 ops/sec [1,596..1,621]	🔴 -1.6%
atob(btoa(short))	1,006 ops/sec [994..1,017] → 1,005 ops/sec [983..1,013]	~ overlap (-0.2%)	1,017 ops/sec [1,004..1,043] → 1,020 ops/sec [1,012..1,119]	~ overlap (+0.3%)
atob(btoa(medium))	39 ops/sec [38..39] → 37 ops/sec [37..38]	🔴 -3.1%	38 ops/sec [38..39] → 41 ops/sec [39..42]	~ overlap (+6.9%)

classes.js — Interp: 🔴 7, 24 unch. · avg -2.4% · Bytecode: 🟢 1, 🔴 3, 27 unch. · avg +1.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple class new	39,422 ops/sec [39,253..39,773] → 39,364 ops/sec [39,063..44,237]	~ overlap (-0.1%)	53,209 ops/sec [52,855..53,411] → 53,833 ops/sec [53,425..59,506]	🟢 +1.2%
class with defaults	30,962 ops/sec [30,392..31,276] → 33,681 ops/sec [30,187..34,345]	~ overlap (+8.8%)	35,833 ops/sec [34,304..36,714] → 36,170 ops/sec [35,124..36,497]	~ overlap (+0.9%)
50 instances via Array.from	1,429 ops/sec [1,390..1,492] → 1,415 ops/sec [1,392..1,422]	~ overlap (-1.0%)	1,661 ops/sec [1,645..1,665] → 1,662 ops/sec [1,643..1,664]	~ overlap (+0.1%)
instance method call	18,145 ops/sec [18,015..20,243] → 18,130 ops/sec [17,689..18,420]	~ overlap (-0.1%)	27,743 ops/sec [27,097..27,770] → 28,046 ops/sec [27,215..29,374]	~ overlap (+1.1%)
static method call	32,155 ops/sec [31,340..33,358] → 31,061 ops/sec [30,791..32,200]	~ overlap (-3.4%)	56,967 ops/sec [56,407..60,980] → 57,226 ops/sec [56,671..66,858]	~ overlap (+0.5%)
single-level inheritance	16,170 ops/sec [16,077..17,581] → 16,010 ops/sec [15,737..16,709]	~ overlap (-1.0%)	20,472 ops/sec [19,671..22,185] → 19,551 ops/sec [19,205..20,073]	~ overlap (-4.5%)
two-level inheritance	14,264 ops/sec [13,950..22,547] → 14,752 ops/sec [13,934..16,643]	~ overlap (+3.4%)	15,247 ops/sec [15,085..15,315] → 14,999 ops/sec [14,892..16,541]	~ overlap (-1.6%)
private field access	20,192 ops/sec [19,986..20,342] → 20,692 ops/sec [19,679..23,618]	~ overlap (+2.5%)	14,882 ops/sec [14,689..14,926] → 14,657 ops/sec [14,139..16,247]	~ overlap (-1.5%)
private methods	22,560 ops/sec [22,457..22,753] → 22,145 ops/sec [21,937..22,270]	🔴 -1.8%	16,980 ops/sec [16,830..17,926] → 16,495 ops/sec [16,397..16,641]	🔴 -2.9%
getter/setter access	23,315 ops/sec [21,985..23,658] → 21,335 ops/sec [21,088..21,787]	🔴 -8.5%	29,731 ops/sec [29,576..29,959] → 31,998 ops/sec [28,421..32,395]	~ overlap (+7.6%)
class decorator (identity)	32,774 ops/sec [32,727..32,824] → 34,835 ops/sec [31,809..39,252]	~ overlap (+6.3%)	33,699 ops/sec [33,226..34,456] → 32,749 ops/sec [32,544..33,134]	🔴 -2.8%
class decorator (wrapping)	17,813 ops/sec [17,649..17,853] → 17,374 ops/sec [17,133..17,450]	🔴 -2.5%	17,276 ops/sec [16,781..17,620] → 17,347 ops/sec [17,236..17,495]	~ overlap (+0.4%)
identity method decorator	22,739 ops/sec [22,484..23,090] → 22,294 ops/sec [21,645..31,464]	~ overlap (-2.0%)	27,549 ops/sec [26,943..27,999] → 28,996 ops/sec [27,432..30,249]	~ overlap (+5.3%)
wrapping method decorator	18,184 ops/sec [11,119..27,999] → 17,579 ops/sec [17,365..25,190]	~ overlap (-3.3%)	21,035 ops/sec [20,957..22,788] → 20,774 ops/sec [20,560..20,934]	🔴 -1.2%
stacked method decorators (x3)	13,424 ops/sec [13,094..13,676] → 12,787 ops/sec [12,639..13,033]	🔴 -4.7%	15,560 ops/sec [15,092..16,426] → 15,249 ops/sec [15,044..15,738]	~ overlap (-2.0%)
identity field decorator	26,886 ops/sec [24,790..28,642] → 25,755 ops/sec [25,352..25,910]	~ overlap (-4.2%)	26,977 ops/sec [25,161..29,554] → 30,765 ops/sec [28,451..32,122]	~ overlap (+14.0%)
field initializer decorator	22,094 ops/sec [21,675..22,106] → 21,298 ops/sec [20,544..24,178]	~ overlap (-3.6%)	23,455 ops/sec [23,195..30,108] → 23,477 ops/sec [23,272..27,868]	~ overlap (+0.1%)
getter decorator (identity)	21,169 ops/sec [20,573..22,822] → 20,858 ops/sec [20,256..22,864]	~ overlap (-1.5%)	18,480 ops/sec [18,344..22,399] → 18,603 ops/sec [18,492..22,788]	~ overlap (+0.7%)
setter decorator (identity)	16,567 ops/sec [15,523..16,928] → 16,554 ops/sec [16,287..17,596]	~ overlap (-0.1%)	14,990 ops/sec [14,788..15,686] → 14,923 ops/sec [14,019..15,335]	~ overlap (-0.4%)
static method decorator	23,828 ops/sec [22,795..26,568] → 23,475 ops/sec [23,195..26,194]	~ overlap (-1.5%)	30,980 ops/sec [30,138..33,546] → 33,916 ops/sec [31,150..36,036]	~ overlap (+9.5%)
static field decorator	31,590 ops/sec [28,980..38,500] → 28,124 ops/sec [27,555..28,254]	🔴 -11.0%	34,527 ops/sec [33,267..36,295] → 34,444 ops/sec [34,051..34,576]	~ overlap (-0.2%)
private method decorator	17,434 ops/sec [16,928..17,801] → 17,046 ops/sec [16,812..19,132]	~ overlap (-2.2%)	20,277 ops/sec [19,920..20,546] → 20,159 ops/sec [20,011..20,320]	~ overlap (-0.6%)
private field decorator	20,469 ops/sec [20,180..20,524] → 19,369 ops/sec [18,893..19,950]	🔴 -5.4%	18,354 ops/sec [18,292..18,630] → 18,410 ops/sec [18,345..21,708]	~ overlap (+0.3%)
plain auto-accessor (no decorator)	35,660 ops/sec [34,957..35,800] → 33,990 ops/sec [33,132..39,371]	~ overlap (-4.7%)	34,677 ops/sec [34,202..35,324] → 36,917 ops/sec [34,303..38,798]	~ overlap (+6.5%)
auto-accessor with decorator	23,966 ops/sec [19,846..24,490] → 19,528 ops/sec [19,426..19,989]	~ overlap (-18.5%)	20,669 ops/sec [20,510..20,741] → 21,146 ops/sec [20,306..23,300]	~ overlap (+2.3%)
decorator writing metadata	16,230 ops/sec [16,065..16,431] → 15,968 ops/sec [15,914..16,146]	~ overlap (-1.6%)	19,286 ops/sec [18,737..19,505] → 19,063 ops/sec [18,710..19,158]	~ overlap (-1.2%)
static getter read	40,658 ops/sec [38,206..46,118] → 37,714 ops/sec [37,490..37,928]	🔴 -7.2%	53,508 ops/sec [52,590..54,192] → 53,382 ops/sec [52,641..53,552]	~ overlap (-0.2%)
static getter/setter pair	27,320 ops/sec [26,627..27,795] → 27,186 ops/sec [26,269..29,140]	~ overlap (-0.5%)	39,646 ops/sec [38,416..53,222] → 39,323 ops/sec [38,805..46,329]	~ overlap (-0.8%)
inherited static getter	24,804 ops/sec [24,607..25,093] → 24,404 ops/sec [23,945..24,672]	~ overlap (-1.6%)	33,870 ops/sec [32,120..37,733] → 39,336 ops/sec [33,448..44,326]	~ overlap (+16.1%)
inherited static setter	25,742 ops/sec [25,211..26,028] → 25,466 ops/sec [25,269..30,452]	~ overlap (-1.1%)	37,163 ops/sec [32,532..40,494] → 35,176 ops/sec [33,489..38,516]	~ overlap (-5.3%)
inherited static getter with this binding	19,667 ops/sec [19,553..19,796] → 19,110 ops/sec [18,716..20,314]	~ overlap (-2.8%)	27,638 ops/sec [26,296..29,303] → 26,891 ops/sec [26,278..27,384]	~ overlap (-2.7%)

closures.js — Interp: 🔴 2, 9 unch. · avg -0.3% · Bytecode: 11 unch. · avg +0.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
closure over single variable	27,879 ops/sec [27,522..28,291] → 27,632 ops/sec [26,965..29,693]	~ overlap (-0.9%)	88,187 ops/sec [87,657..88,464] → 89,881 ops/sec [87,086..92,096]	~ overlap (+1.9%)
closure over multiple variables	35,319 ops/sec [34,051..39,972] → 34,395 ops/sec [32,770..34,849]	~ overlap (-2.6%)	90,481 ops/sec [86,827..91,639] → 84,381 ops/sec [84,004..87,561]	~ overlap (-6.7%)
nested closures	37,536 ops/sec [36,556..40,750] → 37,037 ops/sec [35,971..41,243]	~ overlap (-1.3%)	85,068 ops/sec [84,916..86,727] → 86,801 ops/sec [83,195..87,394]	~ overlap (+2.0%)
function as argument	28,438 ops/sec [28,272..28,643] → 27,251 ops/sec [27,146..27,991]	🔴 -4.2%	81,685 ops/sec [81,495..85,476] → 83,411 ops/sec [83,067..83,993]	~ overlap (+2.1%)
function returning function	35,351 ops/sec [34,956..36,315] → 34,953 ops/sec [34,319..36,612]	~ overlap (-1.1%)	94,757 ops/sec [91,835..95,371] → 95,423 ops/sec [95,003..95,982]	~ overlap (+0.7%)
compose two functions	22,198 ops/sec [20,704..22,438] → 23,070 ops/sec [21,968..26,830]	~ overlap (+3.9%)	57,069 ops/sec [56,646..57,412] → 57,033 ops/sec [56,595..63,624]	~ overlap (-0.1%)
fn.call	48,888 ops/sec [48,605..49,164] → 48,881 ops/sec [47,766..50,612]	~ overlap (-0.0%)	72,759 ops/sec [71,705..76,050] → 72,342 ops/sec [71,622..72,860]	~ overlap (-0.6%)
fn.apply	38,739 ops/sec [37,880..40,169] → 37,640 ops/sec [37,353..46,615]	~ overlap (-2.8%)	69,002 ops/sec [67,095..80,709] → 69,608 ops/sec [67,096..74,447]	~ overlap (+0.9%)
fn.bind	36,181 ops/sec [31,675..41,923] → 43,615 ops/sec [41,435..43,980]	~ overlap (+20.5%)	93,093 ops/sec [91,847..95,691] → 102,082 ops/sec [91,947..116,772]	~ overlap (+9.7%)
recursive sum to 50	3,316 ops/sec [3,190..3,769] → 3,431 ops/sec [3,350..3,741]	~ overlap (+3.5%)	11,826 ops/sec [11,784..11,914] → 11,680 ops/sec [11,554..12,933]	~ overlap (-1.2%)
recursive tree traversal	6,000 ops/sec [5,832..6,425] → 4,880 ops/sec [4,851..5,031]	🔴 -18.7%	11,892 ops/sec [11,166..16,156] → 11,181 ops/sec [10,942..11,341]	~ overlap (-6.0%)

collections.js — Interp: 🔴 1, 11 unch. · avg +0.4% · Bytecode: 🔴 2, 10 unch. · avg +1.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
add 50 elements	2,982 ops/sec [2,899..3,054] → 2,823 ops/sec [2,808..3,408]	~ overlap (-5.3%)	3,937 ops/sec [3,829..4,495] → 3,742 ops/sec [3,692..3,781]	🔴 -4.9%
has lookup (50 elements)	62,567 ops/sec [61,795..62,898] → 61,813 ops/sec [61,616..62,120]	~ overlap (-1.2%)	110,238 ops/sec [95,840..123,207] → 96,641 ops/sec [96,025..96,827]	~ overlap (-12.3%)
delete elements	33,758 ops/sec [33,381..34,751] → 33,702 ops/sec [32,785..34,059]	~ overlap (-0.2%)	51,037 ops/sec [47,159..53,481] → 46,719 ops/sec [46,267..46,799]	🔴 -8.5%
forEach iteration	4,253 ops/sec [3,738..4,728] → 4,282 ops/sec [3,561..5,068]	~ overlap (+0.7%)	6,470 ops/sec [6,435..6,500] → 7,211 ops/sec [6,271..7,481]	~ overlap (+11.5%)
spread to array	13,212 ops/sec [12,666..13,345] → 14,202 ops/sec [11,374..15,014]	~ overlap (+7.5%)	72,081 ops/sec [70,414..115,183] → 76,844 ops/sec [68,491..83,628]	~ overlap (+6.6%)
deduplicate array	20,514 ops/sec [19,632..22,646] → 20,655 ops/sec [18,266..24,208]	~ overlap (+0.7%)	40,109 ops/sec [39,743..41,733] → 43,883 ops/sec [40,350..46,807]	~ overlap (+9.4%)
set 50 entries	2,195 ops/sec [2,192..2,213] → 2,132 ops/sec [2,100..2,137]	🔴 -2.9%	2,889 ops/sec [2,867..4,227] → 3,133 ops/sec [2,907..3,302]	~ overlap (+8.4%)
get lookup (50 entries)	64,682 ops/sec [62,253..65,073] → 64,031 ops/sec [63,806..64,460]	~ overlap (-1.0%)	85,942 ops/sec [84,078..113,986] → 85,504 ops/sec [84,685..100,863]	~ overlap (-0.5%)
has check	82,390 ops/sec [81,514..106,595] → 83,585 ops/sec [79,695..88,475]	~ overlap (+1.5%)	110,821 ops/sec [108,784..148,984] → 110,274 ops/sec [109,720..132,907]	~ overlap (-0.5%)
delete entries	33,592 ops/sec [33,388..33,917] → 33,759 ops/sec [32,769..34,248]	~ overlap (+0.5%)	45,535 ops/sec [43,723..64,104] → 44,526 ops/sec [43,748..47,877]	~ overlap (-2.2%)
forEach iteration	3,725 ops/sec [3,672..4,130] → 3,632 ops/sec [3,604..3,846]	~ overlap (-2.5%)	6,789 ops/sec [6,185..8,065] → 6,390 ops/sec [6,368..7,290]	~ overlap (-5.9%)
keys/values/entries	3,463 ops/sec [3,353..3,728] → 3,703 ops/sec [3,371..4,746]	~ overlap (+6.9%)	11,285 ops/sec [11,182..11,613] → 12,736 ops/sec [11,567..13,529]	~ overlap (+12.9%)

csv.js — Interp: 🔴 3, 10 unch. · avg +0.2% · Bytecode: 🔴 1, 12 unch. · avg -0.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple 3-column CSV	39,992 ops/sec [39,607..40,361] → 39,216 ops/sec [39,114..39,241]	🔴 -1.9%	53,239 ops/sec [42,973..59,491] → 43,524 ops/sec [43,271..43,841]	~ overlap (-18.2%)
parse 10-row CSV	11,566 ops/sec [11,285..11,581] → 11,175 ops/sec [11,148..12,810]	~ overlap (-3.4%)	11,899 ops/sec [11,857..11,918] → 11,796 ops/sec [11,649..12,860]	~ overlap (-0.9%)
parse 100-row CSV	1,974 ops/sec [1,389..2,188] → 1,866 ops/sec [1,709..2,033]	~ overlap (-5.5%)	1,864 ops/sec [1,847..2,108] → 1,888 ops/sec [1,858..2,102]	~ overlap (+1.3%)
parse CSV with quoted fields	58,128 ops/sec [57,098..59,372] → 56,349 ops/sec [55,306..56,599]	🔴 -3.1%	65,146 ops/sec [63,563..77,798] → 65,794 ops/sec [63,686..68,240]	~ overlap (+1.0%)
parse without headers (array of arrays)	5,467 ops/sec [5,307..5,518] → 6,001 ops/sec [5,282..6,590]	~ overlap (+9.8%)	5,814 ops/sec [5,347..6,473] → 6,010 ops/sec [5,656..6,479]	~ overlap (+3.4%)
parse with semicolon delimiter	8,662 ops/sec [8,493..10,250] → 8,263 ops/sec [8,208..8,278]	🔴 -4.6%	8,509 ops/sec [8,321..10,415] → 8,831 ops/sec [8,517..8,914]	~ overlap (+3.8%)
stringify array of objects	55,402 ops/sec [52,828..58,374] → 55,768 ops/sec [55,350..56,151]	~ overlap (+0.7%)	65,474 ops/sec [60,709..67,279] → 63,279 ops/sec [63,113..63,645]	~ overlap (-3.4%)
stringify array of arrays	22,317 ops/sec [22,050..25,955] → 22,644 ops/sec [22,333..22,862]	~ overlap (+1.5%)	23,639 ops/sec [23,572..23,830] → 23,568 ops/sec [23,466..23,677]	~ overlap (-0.3%)
stringify with values needing escaping	43,724 ops/sec [42,917..54,776] → 43,769 ops/sec [42,899..45,957]	~ overlap (+0.1%)	48,884 ops/sec [48,699..49,050] → 48,598 ops/sec [48,576..48,620]	🔴 -0.6%
reviver converts numbers	887 ops/sec [864..998] → 866 ops/sec [859..883]	~ overlap (-2.4%)	1,108 ops/sec [1,100..1,117] → 1,110 ops/sec [1,104..1,113]	~ overlap (+0.1%)
reviver filters empty to null	7,294 ops/sec [6,729..7,496] → 7,775 ops/sec [7,125..9,334]	~ overlap (+6.6%)	10,249 ops/sec [9,933..10,352] → 10,275 ops/sec [10,193..10,330]	~ overlap (+0.3%)
parse then stringify	7,559 ops/sec [7,367..7,628] → 7,325 ops/sec [7,254..8,857]	~ overlap (-3.1%)	7,726 ops/sec [7,610..7,737] → 7,755 ops/sec [7,691..7,789]	~ overlap (+0.4%)
stringify then parse	7,315 ops/sec [7,106..7,333] → 7,891 ops/sec [7,126..10,617]	~ overlap (+7.9%)	7,505 ops/sec [7,469..9,030] → 7,576 ops/sec [7,544..7,580]	~ overlap (+0.9%)

destructuring.js — Interp: 🔴 1, 21 unch. · avg -0.9% · Bytecode: 🟢 1, 🔴 2, 19 unch. · avg -1.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple array destructuring	66,019 ops/sec [64,605..72,651] → 64,093 ops/sec [63,150..77,227]	~ overlap (-2.9%)	89,123 ops/sec [81,527..96,607] → 81,882 ops/sec [79,995..94,408]	~ overlap (-8.1%)
with rest element	54,235 ops/sec [50,539..57,021] → 54,032 ops/sec [53,221..58,255]	~ overlap (-0.4%)	64,340 ops/sec [63,999..67,322] → 64,955 ops/sec [63,198..65,263]	~ overlap (+1.0%)
with defaults	66,932 ops/sec [65,067..70,112] → 66,328 ops/sec [63,823..67,170]	~ overlap (-0.9%)	88,872 ops/sec [87,988..95,397] → 87,175 ops/sec [83,940..97,861]	~ overlap (-1.9%)
skip elements	73,864 ops/sec [71,746..80,932] → 72,403 ops/sec [71,230..74,834]	~ overlap (-2.0%)	95,684 ops/sec [90,131..102,495] → 89,386 ops/sec [88,905..126,341]	~ overlap (-6.6%)
nested array destructuring	30,449 ops/sec [30,265..30,562] → 31,295 ops/sec [30,369..33,285]	~ overlap (+2.8%)	31,484 ops/sec [31,249..31,855] → 32,040 ops/sec [31,517..32,737]	~ overlap (+1.8%)
swap variables	90,603 ops/sec [89,375..91,135] → 90,310 ops/sec [86,114..93,280]	~ overlap (-0.3%)	125,641 ops/sec [120,646..141,395] → 122,570 ops/sec [121,641..123,540]	~ overlap (-2.4%)
simple object destructuring	79,934 ops/sec [79,847..80,372] → 79,000 ops/sec [76,497..80,192]	~ overlap (-1.2%)	92,955 ops/sec [92,558..93,846] → 92,457 ops/sec [92,158..93,886]	~ overlap (-0.5%)
with defaults	89,630 ops/sec [87,195..90,506] → 85,747 ops/sec [83,547..90,442]	~ overlap (-4.3%)	133,810 ops/sec [132,551..136,916] → 134,215 ops/sec [133,144..135,437]	~ overlap (+0.3%)
with renaming	89,717 ops/sec [88,089..90,972] → 88,408 ops/sec [86,727..89,831]	~ overlap (-1.5%)	98,983 ops/sec [98,689..99,346] → 100,896 ops/sec [100,103..101,504]	🟢 +1.9%
nested object destructuring	48,867 ops/sec [47,725..49,125] → 48,385 ops/sec [47,992..48,623]	~ overlap (-1.0%)	50,778 ops/sec [50,696..51,295] → 50,218 ops/sec [49,401..52,325]	~ overlap (-1.1%)
rest properties	36,316 ops/sec [35,638..41,570] → 36,513 ops/sec [35,808..38,914]	~ overlap (+0.5%)	44,229 ops/sec [43,333..45,815] → 44,682 ops/sec [44,375..44,828]	~ overlap (+1.0%)
object parameter	26,172 ops/sec [25,663..26,553] → 25,857 ops/sec [25,457..26,546]	~ overlap (-1.2%)	43,164 ops/sec [40,508..46,304] → 43,621 ops/sec [42,954..45,482]	~ overlap (+1.1%)
array parameter	33,524 ops/sec [30,518..37,212] → 30,348 ops/sec [30,099..30,626]	~ overlap (-9.5%)	42,331 ops/sec [41,423..51,951] → 42,668 ops/sec [42,602..44,113]	~ overlap (+0.8%)
mixed destructuring in map	8,196 ops/sec [8,130..8,500] → 8,189 ops/sec [7,730..8,321]	~ overlap (-0.1%)	11,610 ops/sec [11,251..13,182] → 11,173 ops/sec [10,969..12,764]	~ overlap (-3.8%)
forEach with array destructuring	13,547 ops/sec [13,333..13,599] → 13,246 ops/sec [13,146..13,296]	🔴 -2.2%	16,576 ops/sec [15,464..17,534] → 15,679 ops/sec [15,480..15,725]	~ overlap (-5.4%)
map with array destructuring	15,422 ops/sec [15,333..15,477] → 15,506 ops/sec [15,214..16,638]	~ overlap (+0.5%)	15,111 ops/sec [14,444..16,457] → 15,435 ops/sec [15,112..15,493]	~ overlap (+2.1%)
filter with array destructuring	15,709 ops/sec [15,590..19,159] → 16,021 ops/sec [15,939..16,054]	~ overlap (+2.0%)	16,187 ops/sec [16,070..17,454] → 17,721 ops/sec [16,199..19,085]	~ overlap (+9.5%)
reduce with array destructuring	16,737 ops/sec [16,663..16,864] → 16,592 ops/sec [16,328..17,262]	~ overlap (-0.9%)	16,780 ops/sec [16,666..16,884] → 16,508 ops/sec [16,436..16,577]	🔴 -1.6%
map with object destructuring	19,113 ops/sec [18,672..19,216] → 18,621 ops/sec [18,396..19,615]	~ overlap (-2.6%)	23,539 ops/sec [23,247..23,604] → 22,633 ops/sec [22,029..24,119]	~ overlap (-3.8%)
map with nested destructuring	15,521 ops/sec [15,203..18,846] → 15,829 ops/sec [15,478..16,022]	~ overlap (+2.0%)	23,468 ops/sec [23,291..24,785] → 23,744 ops/sec [21,729..24,528]	~ overlap (+1.2%)
map with rest in destructuring	8,428 ops/sec [8,217..8,759] → 8,515 ops/sec [8,477..8,636]	~ overlap (+1.0%)	8,124 ops/sec [7,856..8,940] → 8,300 ops/sec [7,975..12,150]	~ overlap (+2.2%)
map with defaults in destructuring	10,253 ops/sec [10,064..10,430] → 10,530 ops/sec [10,183..10,869]	~ overlap (+2.7%)	19,403 ops/sec [18,722..19,645] → 17,701 ops/sec [17,565..18,075]	🔴 -8.8%

fibonacci.js — Interp: 🔴 1, 7 unch. · avg -1.7% · Bytecode: 🟢 1, 7 unch. · avg +0.6%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
recursive fib(15)	92 ops/sec [89..94] → 90 ops/sec [89..125]	~ overlap (-2.3%)	323 ops/sec [317..325] → 324 ops/sec [317..364]	~ overlap (+0.3%)
recursive fib(20)	9 ops/sec [9..10] → 9 ops/sec [9..10]	~ overlap (+2.5%)	30 ops/sec [29..33] → 29 ops/sec [29..31]	~ overlap (-3.1%)
recursive fib(15) typed	97 ops/sec [95..99] → 92 ops/sec [89..93]	🔴 -6.0%	344 ops/sec [336..354] → 329 ops/sec [323..378]	~ overlap (-4.5%)
recursive fib(20) typed	9 ops/sec [8..9] → 9 ops/sec [8..9]	~ overlap (-0.3%)	31 ops/sec [29..32] → 34 ops/sec [29..37]	~ overlap (+7.8%)
iterative fib(20) via reduce	4,063 ops/sec [3,886..4,416] → 3,979 ops/sec [3,890..4,136]	~ overlap (-2.1%)	6,227 ops/sec [6,043..6,263] → 6,353 ops/sec [6,154..7,202]	~ overlap (+2.0%)
iterator fib(20)	2,346 ops/sec [2,271..2,632] → 2,273 ops/sec [2,260..2,820]	~ overlap (-3.1%)	4,822 ops/sec [4,639..4,934] → 4,825 ops/sec [4,695..4,927]	~ overlap (+0.1%)
iterator fib(20) via Iterator.from + take	2,247 ops/sec [2,231..2,662] → 2,141 ops/sec [2,131..2,430]	~ overlap (-4.7%)	2,746 ops/sec [2,431..3,527] → 2,748 ops/sec [2,737..2,758]	~ overlap (+0.1%)
iterator fib(20) last value via reduce	1,920 ops/sec [1,878..1,958] → 1,967 ops/sec [1,820..2,049]	~ overlap (+2.4%)	2,255 ops/sec [2,200..2,271] → 2,294 ops/sec [2,281..2,303]	🟢 +1.7%

float16array.js — Interp: 🔴 3, 29 unch. · avg -1.7% · Bytecode: 🔴 1, 31 unch. · avg +0.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
new Float16Array(0)	90,467 ops/sec [89,903..90,717] → 89,607 ops/sec [88,360..96,121]	~ overlap (-1.0%)	106,281 ops/sec [103,344..109,251] → 109,575 ops/sec [108,780..110,093]	~ overlap (+3.1%)
new Float16Array(100)	88,548 ops/sec [87,359..88,581] → 85,784 ops/sec [84,506..85,905]	🔴 -3.1%	116,626 ops/sec [101,085..120,344] → 104,197 ops/sec [103,050..132,335]	~ overlap (-10.7%)
new Float16Array(1000)	76,828 ops/sec [76,438..77,454] → 75,318 ops/sec [73,656..83,927]	~ overlap (-2.0%)	88,158 ops/sec [80,582..95,260] → 89,868 ops/sec [88,680..91,634]	~ overlap (+1.9%)
Float16Array.from([...100])	1,554 ops/sec [1,497..2,046] → 1,569 ops/sec [1,503..1,667]	~ overlap (+1.0%)	1,531 ops/sec [1,523..1,583] → 1,858 ops/sec [1,541..1,882]	~ overlap (+21.3%)
Float16Array.of(1.5, 2.5, 3.5, 4.5, 5.5)	76,406 ops/sec [69,649..77,665] → 75,725 ops/sec [75,224..76,111]	~ overlap (-0.9%)	74,085 ops/sec [71,562..90,336] → 72,590 ops/sec [72,294..72,928]	~ overlap (-2.0%)
new Float16Array(float64Array)	24,482 ops/sec [24,173..25,002] → 24,416 ops/sec [24,243..24,498]	~ overlap (-0.3%)	26,119 ops/sec [25,424..33,055] → 26,197 ops/sec [25,597..26,406]	~ overlap (+0.3%)
sequential write 100 elements	993 ops/sec [988..997] → 984 ops/sec [973..1,084]	~ overlap (-0.9%)	4,199 ops/sec [4,180..4,659] → 4,106 ops/sec [4,095..4,252]	~ overlap (-2.2%)
sequential read 100 elements	1,128 ops/sec [1,117..1,140] → 1,109 ops/sec [1,100..1,131]	~ overlap (-1.7%)	6,082 ops/sec [6,039..6,384] → 5,926 ops/sec [5,897..6,122]	~ overlap (-2.6%)
write special values (NaN, Inf, -0)	44,020 ops/sec [42,453..46,546] → 42,160 ops/sec [41,783..49,833]	~ overlap (-4.2%)	131,400 ops/sec [112,093..146,396] → 121,126 ops/sec [119,691..121,775]	~ overlap (-7.8%)
Float16Array write	988 ops/sec [979..1,026] → 991 ops/sec [985..994]	~ overlap (+0.3%)	4,248 ops/sec [4,073..4,254] → 4,341 ops/sec [4,066..5,116]	~ overlap (+2.2%)
Float32Array write	1,020 ops/sec [981..1,028] → 1,043 ops/sec [971..1,060]	~ overlap (+2.2%)	4,180 ops/sec [3,813..4,774] → 4,139 ops/sec [4,037..4,261]	~ overlap (-1.0%)
Float64Array write	1,034 ops/sec [1,017..1,189] → 981 ops/sec [963..1,022]	~ overlap (-5.1%)	4,164 ops/sec [4,040..4,284] → 4,206 ops/sec [4,112..4,394]	~ overlap (+1.0%)
Float16Array read	1,106 ops/sec [1,103..1,112] → 1,078 ops/sec [1,050..1,084]	🔴 -2.5%	5,431 ops/sec [5,390..5,528] → 5,563 ops/sec [5,219..6,292]	~ overlap (+2.4%)
Float32Array read	1,141 ops/sec [1,117..1,193] → 1,097 ops/sec [1,090..1,103]	🔴 -3.9%	5,668 ops/sec [5,060..6,127] → 5,602 ops/sec [5,265..5,866]	~ overlap (-1.2%)
Float64Array read	1,108 ops/sec [1,070..1,228] → 1,091 ops/sec [1,083..1,096]	~ overlap (-1.5%)	5,371 ops/sec [5,265..7,021] → 5,578 ops/sec [5,493..5,660]	~ overlap (+3.9%)
fill(1.5)	7,084 ops/sec [6,735..7,475] → 6,939 ops/sec [6,743..8,218]	~ overlap (-2.0%)	6,955 ops/sec [6,860..7,000] → 6,900 ops/sec [6,879..6,921]	~ overlap (-0.8%)
slice()	11,990 ops/sec [11,322..12,837] → 12,354 ops/sec [12,038..13,905]	~ overlap (+3.0%)	12,432 ops/sec [12,010..13,984] → 12,281 ops/sec [12,184..12,377]	~ overlap (-1.2%)
map(x => x * 2)	2,065 ops/sec [2,047..2,086] → 2,092 ops/sec [2,072..2,231]	~ overlap (+1.3%)	2,189 ops/sec [2,083..2,220] → 2,220 ops/sec [2,171..2,272]	~ overlap (+1.4%)
filter(x => x > 25)	2,066 ops/sec [2,043..2,106] → 2,081 ops/sec [2,048..2,089]	~ overlap (+0.7%)	2,282 ops/sec [2,247..2,880] → 2,167 ops/sec [2,157..2,199]	🔴 -5.1%
reduce (sum)	2,032 ops/sec [2,017..2,090] → 2,036 ops/sec [1,838..2,489]	~ overlap (+0.2%)	2,080 ops/sec [2,016..2,087] → 2,002 ops/sec [1,996..2,018]	~ overlap (-3.8%)
sort()	18,728 ops/sec [18,689..18,902] → 17,790 ops/sec [17,710..20,457]	~ overlap (-5.0%)	19,790 ops/sec [19,469..24,208] → 19,963 ops/sec [19,500..23,809]	~ overlap (+0.9%)
indexOf()	25,661 ops/sec [25,358..26,338] → 23,948 ops/sec [23,490..26,190]	~ overlap (-6.7%)	26,830 ops/sec [26,509..27,590] → 27,745 ops/sec [26,838..27,824]	~ overlap (+3.4%)
reverse()	27,783 ops/sec [27,224..28,057] → 27,733 ops/sec [27,230..29,481]	~ overlap (-0.2%)	29,650 ops/sec [29,202..33,807] → 29,234 ops/sec [28,882..33,866]	~ overlap (-1.4%)
toReversed()	22,008 ops/sec [21,432..22,440] → 21,642 ops/sec [21,594..22,002]	~ overlap (-1.7%)	23,151 ops/sec [22,551..31,512] → 23,064 ops/sec [22,597..23,742]	~ overlap (-0.4%)
toSorted()	11,095 ops/sec [10,738..12,088] → 10,996 ops/sec [10,900..11,066]	~ overlap (-0.9%)	11,767 ops/sec [10,759..12,386] → 11,360 ops/sec [11,048..12,678]	~ overlap (-3.5%)
create view over existing buffer	102,789 ops/sec [100,202..109,547] → 104,569 ops/sec [94,012..118,951]	~ overlap (+1.7%)	117,589 ops/sec [116,099..120,832] → 124,656 ops/sec [119,954..152,294]	~ overlap (+6.0%)
subarray()	67,554 ops/sec [65,659..107,107] → 68,056 ops/sec [67,715..68,869]	~ overlap (+0.7%)	76,825 ops/sec [72,584..77,556] → 79,551 ops/sec [76,835..87,479]	~ overlap (+3.5%)
set() from array	103,862 ops/sec [98,869..106,314] → 99,357 ops/sec [98,598..99,783]	~ overlap (-4.3%)	125,683 ops/sec [120,039..129,837] → 130,533 ops/sec [129,483..137,161]	~ overlap (+3.9%)
for-of loop	1,517 ops/sec [1,492..1,527] → 1,498 ops/sec [1,486..1,524]	~ overlap (-1.2%)	6,644 ops/sec [6,295..7,299] → 6,717 ops/sec [6,416..8,404]	~ overlap (+1.1%)
spread into array	7,597 ops/sec [6,189..7,991] → 6,479 ops/sec [5,872..7,753]	~ overlap (-14.7%)	23,654 ops/sec [21,594..27,194] → 23,142 ops/sec [22,687..36,601]	~ overlap (-2.2%)
f16round(1.337)	176,069 ops/sec [163,777..190,618] → 173,759 ops/sec [171,072..202,865]	~ overlap (-1.3%)	219,376 ops/sec [213,201..232,216] → 230,009 ops/sec [229,092..235,476]	~ overlap (+4.8%)
f16round over 100 values	1,113 ops/sec [1,098..1,138] → 1,095 ops/sec [1,040..1,115]	~ overlap (-1.6%)	3,183 ops/sec [3,049..3,920] → 3,082 ops/sec [3,046..3,133]	~ overlap (-3.2%)

for-in/for-in.js — Interp: 🔴 1, 2 unch. · avg -5.0% · Bytecode: 3 unch. · avg +3.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for...in over 50 own keys	3,211 ops/sec [2,896..3,829] → 2,819 ops/sec [2,646..2,874]	🔴 -12.2%	3,860 ops/sec [3,716..3,905] → 3,795 ops/sec [3,726..4,466]	~ overlap (-1.7%)
for...in over an 8-level chain of 50 shared keys	2,124 ops/sec [2,113..2,126] → 2,114 ops/sec [2,063..2,676]	~ overlap (-0.5%)	2,871 ops/sec [2,815..2,960] → 2,886 ops/sec [2,843..3,065]	~ overlap (+0.5%)
for...in over a 16-level chain of 100 shared keys	874 ops/sec [857..994] → 854 ops/sec [831..863]	~ overlap (-2.3%)	1,125 ops/sec [1,082..1,136] → 1,245 ops/sec [1,099..1,373]	~ overlap (+10.7%)

for-of.js — Interp: 🔴 1, 6 unch. · avg +1.8% · Bytecode: 7 unch. · avg +2.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
for...of with 10-element array	13,395 ops/sec [13,343..13,453] → 13,046 ops/sec [12,383..13,918]	~ overlap (-2.6%)	75,720 ops/sec [74,645..76,030] → 73,712 ops/sec [72,518..84,925]	~ overlap (-2.7%)
for...of with 100-element array	1,734 ops/sec [1,560..1,990] → 1,582 ops/sec [1,473..1,814]	~ overlap (-8.8%)	10,193 ops/sec [10,020..10,240] → 10,203 ops/sec [10,019..12,100]	~ overlap (+0.1%)
for...of with string (10 chars)	10,577 ops/sec [10,309..11,139] → 11,543 ops/sec [10,320..13,230]	~ overlap (+9.1%)	27,641 ops/sec [27,334..33,101] → 27,058 ops/sec [26,623..28,175]	~ overlap (-2.1%)
for...of with Set (10 elements)	13,595 ops/sec [13,485..17,471] → 13,435 ops/sec [13,360..13,469]	🔴 -1.2%	82,095 ops/sec [80,875..90,455] → 85,676 ops/sec [81,758..97,470]	~ overlap (+4.4%)
for...of with Map entries (10 entries)	7,153 ops/sec [7,052..7,198] → 7,421 ops/sec [6,938..7,899]	~ overlap (+3.7%)	11,813 ops/sec [11,625..11,952] → 12,231 ops/sec [11,906..12,894]	~ overlap (+3.5%)
for...of with destructuring	8,068 ops/sec [7,897..8,174] → 8,017 ops/sec [7,853..8,391]	~ overlap (-0.6%)	15,852 ops/sec [14,062..16,671] → 16,089 ops/sec [14,137..16,670]	~ overlap (+1.5%)
for-await-of with sync array	7,525 ops/sec [7,285..10,384] → 8,527 ops/sec [8,362..9,503]	~ overlap (+13.3%)	1,803 ops/sec [1,789..2,582] → 1,996 ops/sec [1,754..2,070]	~ overlap (+10.7%)

generators.js — Interp: 4 unch. · avg -2.2% · Bytecode: 4 unch. · avg -0.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
manual next over object generator	687 ops/sec [681..699] → 672 ops/sec [618..886]	~ overlap (-2.1%)	1,051 ops/sec [1,045..1,053] → 1,048 ops/sec [1,011..1,173]	~ overlap (-0.3%)
for...of over object generator	985 ops/sec [975..1,084] → 971 ops/sec [966..996]	~ overlap (-1.5%)	1,507 ops/sec [1,463..1,658] → 1,494 ops/sec [1,446..1,533]	~ overlap (-0.9%)
yield delegation	1,007 ops/sec [993..1,086] → 1,034 ops/sec [985..1,151]	~ overlap (+2.7%)	1,510 ops/sec [1,474..1,535] → 1,591 ops/sec [1,467..2,030]	~ overlap (+5.4%)
class generator method	992 ops/sec [984..1,069] → 915 ops/sec [901..1,072]	~ overlap (-7.8%)	1,522 ops/sec [1,482..1,533] → 1,402 ops/sec [1,357..1,743]	~ overlap (-7.8%)

intl.js — Interp: 🟢 1, 5 unch. · avg +3.0% · Bytecode: 🟢 1, 5 unch. · avg +0.6%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
format decimal	22,762 ops/sec [21,993..24,425] → 24,307 ops/sec [23,684..25,454]	~ overlap (+6.8%)	25,504 ops/sec [24,352..27,207] → 24,859 ops/sec [24,301..25,150]	~ overlap (-2.5%)
format currency	18,268 ops/sec [17,858..18,803] → 20,536 ops/sec [20,254..22,419]	🟢 +12.4%	19,900 ops/sec [19,709..20,015] → 19,892 ops/sec [19,511..20,613]	~ overlap (-0.0%)
format UTC date	2,412 ops/sec [2,371..2,457] → 2,401 ops/sec [2,368..2,418]	~ overlap (-0.4%)	2,494 ops/sec [2,359..2,507] → 2,404 ops/sec [2,396..2,484]	~ overlap (-3.6%)
formatRange UTC dates	3,080 ops/sec [2,946..3,238] → 3,061 ops/sec [3,040..3,088]	~ overlap (-0.6%)	3,257 ops/sec [2,726..3,336] → 3,084 ops/sec [3,061..3,097]	~ overlap (-5.3%)
compare numeric strings	92,759 ops/sec [92,346..95,870] → 95,261 ops/sec [91,177..96,460]	~ overlap (+2.7%)	102,787 ops/sec [102,295..103,502] → 119,444 ops/sec [111,909..122,468]	🟢 +16.2%
sort short string list	18,970 ops/sec [18,569..21,473] → 18,466 ops/sec [18,288..19,229]	~ overlap (-2.7%)	20,822 ops/sec [19,832..22,598] → 20,619 ops/sec [20,464..22,962]	~ overlap (-1.0%)

iterators.js — Interp: 🟢 1, 🔴 14, 27 unch. · avg -2.7% · Bytecode: 🟢 2, 🔴 10, 30 unch. · avg -1.4%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Iterator.from({next}).toArray() — 20 elements	2,748 ops/sec [2,390..2,772] → 2,635 ops/sec [2,502..2,801]	~ overlap (-4.1%)	3,641 ops/sec [3,557..3,668] → 4,107 ops/sec [4,099..4,116]	🟢 +12.8%
Iterator.from({next}).toArray() — 50 elements	1,237 ops/sec [1,178..1,261] → 1,161 ops/sec [1,151..1,162]	🔴 -6.2%	1,627 ops/sec [1,537..1,733] → 1,753 ops/sec [1,717..1,755]	~ overlap (+7.8%)
spread pre-wrapped iterator — 20 elements	3,018 ops/sec [2,973..3,163] → 2,928 ops/sec [2,679..2,938]	🔴 -3.0%	5,378 ops/sec [5,148..6,087] → 5,487 ops/sec [5,419..5,590]	~ overlap (+2.0%)
Iterator.from({next}).forEach — 50 elements	936 ops/sec [871..1,056] → 796 ops/sec [779..808]	🔴 -14.9%	1,241 ops/sec [1,214..1,278] → 1,263 ops/sec [1,249..1,309]	~ overlap (+1.8%)
Iterator.from({next}).reduce — 50 elements	957 ops/sec [894..1,126] → 871 ops/sec [858..873]	🔴 -8.9%	1,238 ops/sec [1,212..1,248] → 1,264 ops/sec [1,255..1,273]	🟢 +2.1%
wrap array iterator	16,376 ops/sec [16,190..19,549] → 16,163 ops/sec [15,332..16,699]	~ overlap (-1.3%)	18,704 ops/sec [18,249..21,341] → 18,027 ops/sec [18,017..18,072]	🔴 -3.6%
wrap plain {next()} object	1,883 ops/sec [1,857..2,099] → 1,824 ops/sec [1,792..2,012]	~ overlap (-3.1%)	2,753 ops/sec [2,737..2,971] → 2,726 ops/sec [2,684..2,768]	~ overlap (-1.0%)
map + toArray (50 elements)	753 ops/sec [708..794] → 673 ops/sec [667..678]	🔴 -10.7%	940 ops/sec [925..1,239] → 892 ops/sec [886..912]	🔴 -5.1%
filter + toArray (50 elements)	808 ops/sec [748..832] → 707 ops/sec [702..708]	🔴 -12.5%	1,046 ops/sec [1,010..1,124] → 973 ops/sec [947..978]	🔴 -6.9%
take(10) + toArray (50 element source)	3,862 ops/sec [3,755..4,548] → 3,701 ops/sec [3,614..3,736]	🔴 -4.2%	5,220 ops/sec [5,162..5,339] → 4,878 ops/sec [4,761..5,184]	~ overlap (-6.6%)
drop(40) + toArray (50 element source)	1,130 ops/sec [961..1,490] → 915 ops/sec [902..929]	🔴 -19.0%	1,355 ops/sec [1,346..1,421] → 1,312 ops/sec [1,301..1,441]	~ overlap (-3.2%)
chained map + filter + take (100 element source)	1,203 ops/sec [1,162..1,476] → 1,296 ops/sec [1,134..1,446]	~ overlap (+7.8%)	1,448 ops/sec [1,334..1,559] → 1,450 ops/sec [1,448..1,466]	~ overlap (+0.1%)
some + every (50 elements)	521 ops/sec [502..532] → 494 ops/sec [467..500]	🔴 -5.1%	727 ops/sec [666..760] → 728 ops/sec [689..733]	~ overlap (+0.2%)
find (50 elements)	1,139 ops/sec [1,092..1,332] → 1,107 ops/sec [1,074..1,333]	~ overlap (-2.8%)	1,626 ops/sec [1,556..1,692] → 1,520 ops/sec [1,497..1,532]	🔴 -6.5%
concat 2 arrays (10 + 10 elements)	6,856 ops/sec [6,468..7,909] → 6,091 ops/sec [6,022..6,162]	🔴 -11.2%	7,586 ops/sec [6,577..8,469] → 6,683 ops/sec [6,528..7,322]	~ overlap (-11.9%)
concat 5 arrays (10 elements each)	2,743 ops/sec [2,532..2,811] → 2,597 ops/sec [2,534..3,291]	~ overlap (-5.3%)	3,065 ops/sec [2,880..3,590] → 2,963 ops/sec [2,786..3,115]	~ overlap (-3.3%)
concat 2 arrays (20 + 20 elements)	3,434 ops/sec [3,324..3,683] → 3,270 ops/sec [3,241..3,464]	~ overlap (-4.8%)	3,924 ops/sec [3,710..4,503] → 3,613 ops/sec [3,530..3,690]	🔴 -7.9%
concat + filter + toArray (20 + 20 elements)	1,477 ops/sec [1,458..1,647] → 1,550 ops/sec [1,452..1,611]	~ overlap (+4.9%)	1,617 ops/sec [1,548..1,702] → 1,883 ops/sec [1,576..2,107]	~ overlap (+16.5%)
concat + map + take (20 + 20 elements, take 10)	3,589 ops/sec [3,526..3,925] → 3,842 ops/sec [3,259..4,269]	~ overlap (+7.0%)	3,865 ops/sec [3,831..3,992] → 4,207 ops/sec [3,897..5,861]	~ overlap (+8.9%)
concat Sets (15 + 15 elements)	4,500 ops/sec [4,470..4,642] → 4,370 ops/sec [4,302..4,407]	🔴 -2.9%	5,077 ops/sec [4,797..5,168] → 4,684 ops/sec [4,523..4,942]	~ overlap (-7.7%)
concat strings (13 + 13 characters)	5,005 ops/sec [4,925..5,110] → 5,143 ops/sec [4,753..5,782]	~ overlap (+2.8%)	5,675 ops/sec [5,484..5,877] → 5,062 ops/sec [4,984..5,102]	🔴 -10.8%
zip 2 arrays (10 + 10 elements)	11,498 ops/sec [11,416..11,565] → 11,990 ops/sec [10,510..12,468]	~ overlap (+4.3%)	15,015 ops/sec [14,478..15,345] → 12,054 ops/sec [11,766..12,142]	🔴 -19.7%
zip 3 arrays (10 elements each)	11,736 ops/sec [10,718..12,987] → 11,998 ops/sec [10,368..14,163]	~ overlap (+2.2%)	11,514 ops/sec [11,329..12,769] → 11,605 ops/sec [11,479..12,513]	~ overlap (+0.8%)
zip 2 arrays (20 + 20 elements)	7,705 ops/sec [6,822..9,167] → 6,627 ops/sec [6,523..6,768]	🔴 -14.0%	7,573 ops/sec [7,451..7,577] → 7,367 ops/sec [7,264..7,402]	🔴 -2.7%
zip 2 arrays (50 + 50 elements)	3,151 ops/sec [3,084..3,234] → 3,030 ops/sec [2,941..3,146]	~ overlap (-3.8%)	3,402 ops/sec [3,376..3,438] → 3,355 ops/sec [3,316..3,686]	~ overlap (-1.4%)
zip shortest mode (20 + 10 elements)	12,291 ops/sec [11,427..12,324] → 13,468 ops/sec [12,754..13,572]	🟢 +9.6%	12,691 ops/sec [12,436..13,006] → 12,516 ops/sec [12,444..12,684]	~ overlap (-1.4%)
zip longest mode (10 + 20 elements)	7,233 ops/sec [6,270..7,602] → 7,021 ops/sec [6,248..7,562]	~ overlap (-2.9%)	7,023 ops/sec [6,950..7,177] → 6,557 ops/sec [6,541..6,587]	🔴 -6.6%
zip strict mode (20 + 20 elements)	6,677 ops/sec [6,606..6,831] → 7,184 ops/sec [6,444..8,319]	~ overlap (+7.6%)	7,164 ops/sec [7,106..7,247] → 8,109 ops/sec [6,797..8,241]	~ overlap (+13.2%)
zip + map + toArray (20 + 20 elements)	2,185 ops/sec [2,160..2,434] → 2,160 ops/sec [2,127..2,754]	~ overlap (-1.2%)	2,232 ops/sec [2,169..3,340] → 2,367 ops/sec [2,173..2,469]	~ overlap (+6.0%)
zip + filter + toArray (20 + 20 elements)	2,408 ops/sec [2,237..2,643] → 2,246 ops/sec [2,165..2,363]	~ overlap (-6.7%)	2,365 ops/sec [2,338..2,458] → 2,360 ops/sec [2,347..2,381]	~ overlap (-0.2%)
zip Sets (15 + 15 elements)	8,904 ops/sec [8,643..8,925] → 8,773 ops/sec [8,514..9,330]	~ overlap (-1.5%)	9,930 ops/sec [9,659..13,553] → 9,547 ops/sec [9,284..11,447]	~ overlap (-3.9%)
zipKeyed 2 keys (10 elements each)	11,522 ops/sec [11,117..13,810] → 12,778 ops/sec [10,588..13,301]	~ overlap (+10.9%)	12,200 ops/sec [12,098..13,141] → 12,070 ops/sec [11,550..13,149]	~ overlap (-1.1%)
zipKeyed 3 keys (20 elements each)	6,138 ops/sec [5,800..6,656] → 5,712 ops/sec [5,597..6,540]	~ overlap (-6.9%)	5,828 ops/sec [5,787..5,894] → 5,910 ops/sec [5,805..6,912]	~ overlap (+1.4%)
zipKeyed longest mode (10 + 20 elements)	6,304 ops/sec [6,190..8,354] → 6,839 ops/sec [6,248..7,715]	~ overlap (+8.5%)	6,457 ops/sec [6,387..6,489] → 6,366 ops/sec [6,252..7,000]	~ overlap (-1.4%)
zipKeyed strict mode (20 + 20 elements)	6,651 ops/sec [6,366..7,677] → 6,776 ops/sec [6,359..7,024]	~ overlap (+1.9%)	7,120 ops/sec [6,581..9,612] → 6,710 ops/sec [6,489..7,214]	~ overlap (-5.8%)
zipKeyed + filter + map (20 elements)	2,032 ops/sec [1,959..2,555] → 1,956 ops/sec [1,955..1,959]	🔴 -3.7%	2,339 ops/sec [2,293..2,578] → 2,287 ops/sec [2,261..2,622]	~ overlap (-2.2%)
array.values().map().filter().toArray()	893 ops/sec [781..952] → 816 ops/sec [800..977]	~ overlap (-8.6%)	931 ops/sec [919..1,091] → 885 ops/sec [877..888]	🔴 -5.0%
array.values().take(5).toArray()	14,019 ops/sec [13,983..14,143] → 13,838 ops/sec [13,362..15,640]	~ overlap (-1.3%)	15,520 ops/sec [15,408..16,815] → 15,339 ops/sec [15,208..15,424]	~ overlap (-1.2%)
array.values().drop(45).toArray()	3,126 ops/sec [2,901..3,158] → 2,997 ops/sec [2,799..3,304]	~ overlap (-4.1%)	3,225 ops/sec [3,193..4,365] → 3,248 ops/sec [3,033..3,366]	~ overlap (+0.7%)
map.entries() chained helpers	1,134 ops/sec [1,103..1,148] → 1,098 ops/sec [1,076..1,102]	🔴 -3.2%	1,140 ops/sec [1,119..1,409] → 1,139 ops/sec [1,126..1,144]	~ overlap (-0.1%)
set.values() chained helpers	2,027 ops/sec [1,967..2,144] → 1,957 ops/sec [1,942..1,988]	~ overlap (-3.4%)	2,226 ops/sec [2,169..3,251] → 2,154 ops/sec [2,110..2,309]	~ overlap (-3.3%)
string iterator map + toArray	2,020 ops/sec [2,014..2,049] → 2,011 ops/sec [1,907..2,121]	~ overlap (-0.4%)	2,135 ops/sec [2,058..2,264] → 2,124 ops/sec [2,046..2,325]	~ overlap (-0.5%)

json.js — Interp: 🟢 1, 🔴 1, 21 unch. · avg +0.5% · Bytecode: 🟢 3, 🔴 4, 16 unch. · avg -0.5%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple object	57,671 ops/sec [56,641..66,610] → 58,304 ops/sec [56,188..62,871]	~ overlap (+1.1%)	68,990 ops/sec [66,698..70,716] → 61,162 ops/sec [59,915..61,732]	🔴 -11.3%
parse nested object	40,615 ops/sec [38,943..41,274] → 43,124 ops/sec [43,088..43,257]	🟢 +6.2%	46,584 ops/sec [44,640..47,038] → 41,733 ops/sec [40,031..42,323]	🔴 -10.4%
parse array of objects	24,571 ops/sec [23,896..36,242] → 26,633 ops/sec [26,468..26,760]	~ overlap (+8.4%)	28,224 ops/sec [27,245..28,501] → 26,952 ops/sec [26,620..27,026]	🔴 -4.5%
parse large flat object	26,314 ops/sec [25,013..31,278] → 27,423 ops/sec [27,049..27,747]	~ overlap (+4.2%)	29,567 ops/sec [29,393..30,009] → 28,796 ops/sec [28,400..28,862]	🔴 -2.6%
parse mixed types	30,527 ops/sec [30,190..36,040] → 31,227 ops/sec [31,109..31,387]	~ overlap (+2.3%)	33,599 ops/sec [33,560..33,751] → 33,569 ops/sec [33,403..33,745]	~ overlap (-0.1%)
stringify simple object	60,003 ops/sec [57,884..61,490] → 57,051 ops/sec [56,150..60,099]	~ overlap (-4.9%)	55,006 ops/sec [54,716..55,403] → 55,768 ops/sec [55,248..58,944]	~ overlap (+1.4%)
stringify nested object	35,596 ops/sec [34,686..35,734] → 35,399 ops/sec [34,227..37,190]	~ overlap (-0.6%)	32,537 ops/sec [31,314..35,151] → 32,187 ops/sec [31,969..32,502]	~ overlap (-1.1%)
stringify array of objects	15,811 ops/sec [15,326..16,180] → 17,634 ops/sec [16,170..18,126]	~ overlap (+11.5%)	16,930 ops/sec [15,064..18,848] → 17,381 ops/sec [16,516..19,154]	~ overlap (+2.7%)
stringify mixed types	24,321 ops/sec [23,535..24,668] → 23,718 ops/sec [23,005..24,682]	~ overlap (-2.5%)	22,132 ops/sec [21,570..23,868] → 22,035 ops/sec [21,904..22,294]	~ overlap (-0.4%)
reviver doubles numbers	10,018 ops/sec [9,945..10,066] → 10,195 ops/sec [9,767..12,881]	~ overlap (+1.8%)	14,121 ops/sec [13,947..15,065] → 14,549 ops/sec [13,992..15,996]	~ overlap (+3.0%)
reviver filters properties	10,486 ops/sec [9,907..11,427] → 9,485 ops/sec [9,243..10,704]	~ overlap (-9.5%)	12,570 ops/sec [12,329..12,673] → 12,891 ops/sec [12,833..12,956]	🟢 +2.6%
reviver on nested object	11,868 ops/sec [11,858..11,882] → 11,257 ops/sec [11,216..11,275]	🔴 -5.2%	15,402 ops/sec [14,408..15,546] → 15,585 ops/sec [13,741..19,380]	~ overlap (+1.2%)
reviver on array	6,235 ops/sec [6,120..6,485] → 6,088 ops/sec [5,770..6,177]	~ overlap (-2.4%)	8,921 ops/sec [8,887..10,531] → 8,973 ops/sec [8,739..11,567]	~ overlap (+0.6%)
replacer function doubles numbers	10,871 ops/sec [10,718..11,550] → 10,713 ops/sec [10,585..11,142]	~ overlap (-1.5%)	14,987 ops/sec [14,878..15,079] → 15,352 ops/sec [15,224..15,417]	🟢 +2.4%
replacer function excludes properties	14,030 ops/sec [13,987..14,200] → 14,259 ops/sec [13,672..17,196]	~ overlap (+1.6%)	18,455 ops/sec [17,923..18,923] → 18,632 ops/sec [18,506..22,260]	~ overlap (+1.0%)
array replacer (allowlist)	37,930 ops/sec [36,739..38,808] → 38,860 ops/sec [36,372..39,065]	~ overlap (+2.5%)	35,303 ops/sec [32,852..35,956] → 34,242 ops/sec [33,931..34,420]	~ overlap (-3.0%)
stringify with 2-space indent	36,985 ops/sec [31,662..38,703] → 30,239 ops/sec [29,541..32,352]	~ overlap (-18.2%)	30,071 ops/sec [29,976..31,482] → 33,813 ops/sec [29,967..39,054]	~ overlap (+12.4%)
stringify with tab indent	31,656 ops/sec [30,644..42,335] → 31,753 ops/sec [29,447..32,253]	~ overlap (+0.3%)	30,588 ops/sec [29,876..30,831] → 30,946 ops/sec [30,229..33,849]	~ overlap (+1.2%)
stringify deeply nested object with 2-space indent	6,747 ops/sec [6,025..8,135] → 6,761 ops/sec [6,372..7,106]	~ overlap (+0.2%)	6,795 ops/sec [6,707..7,008] → 6,733 ops/sec [6,664..6,861]	~ overlap (-0.9%)
stringify deeply nested array with 2-space indent	9,921 ops/sec [9,579..12,492] → 9,458 ops/sec [9,129..9,960]	~ overlap (-4.7%)	9,396 ops/sec [9,047..9,957] → 9,667 ops/sec [9,560..9,701]	~ overlap (+2.9%)
stringify very deeply nested object with 2-space indent	1,214 ops/sec [1,158..1,395] → 1,305 ops/sec [1,201..1,415]	~ overlap (+7.5%)	1,102 ops/sec [1,096..1,107] → 1,162 ops/sec [1,139..1,201]	🟢 +5.4%
parse then stringify	19,638 ops/sec [18,885..20,163] → 19,910 ops/sec [19,516..23,879]	~ overlap (+1.4%)	21,883 ops/sec [21,827..21,900] → 20,224 ops/sec [18,983..22,111]	~ overlap (-7.6%)
stringify then parse	11,970 ops/sec [11,663..14,973] → 13,473 ops/sec [12,214..15,750]	~ overlap (+12.6%)	12,944 ops/sec [12,875..13,071] → 11,990 ops/sec [11,918..12,957]	~ overlap (-7.4%)

jsx.jsx — Interp: 🔴 1, 20 unch. · avg -2.7% · Bytecode: 🟢 1, 20 unch. · avg +0.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
simple element	77,481 ops/sec [74,255..98,074] → 80,331 ops/sec [76,785..81,254]	~ overlap (+3.7%)	86,794 ops/sec [82,387..104,274] → 87,302 ops/sec [85,662..88,305]	~ overlap (+0.6%)
self-closing element	80,862 ops/sec [77,864..90,601] → 78,310 ops/sec [77,181..79,572]	~ overlap (-3.2%)	90,285 ops/sec [88,447..92,734] → 90,559 ops/sec [89,904..93,272]	~ overlap (+0.3%)
element with string attribute	68,474 ops/sec [65,893..68,532] → 67,359 ops/sec [64,970..84,021]	~ overlap (-1.6%)	67,640 ops/sec [65,907..101,016] → 70,497 ops/sec [70,312..70,686]	~ overlap (+4.2%)
element with multiple attributes	57,509 ops/sec [57,112..58,200] → 58,335 ops/sec [56,071..60,742]	~ overlap (+1.4%)	49,595 ops/sec [47,868..57,616] → 51,917 ops/sec [51,509..53,834]	~ overlap (+4.7%)
element with expression attribute	59,188 ops/sec [58,672..76,716] → 59,067 ops/sec [57,472..74,700]	~ overlap (-0.2%)	69,658 ops/sec [68,891..74,600] → 70,634 ops/sec [68,109..71,083]	~ overlap (+1.4%)
text child	78,080 ops/sec [74,909..103,078] → 75,033 ops/sec [73,635..84,138]	~ overlap (-3.9%)	87,771 ops/sec [81,025..102,295] → 84,886 ops/sec [84,252..102,909]	~ overlap (-3.3%)
expression child	78,221 ops/sec [70,265..86,292] → 70,142 ops/sec [68,532..70,788]	~ overlap (-10.3%)	80,350 ops/sec [79,828..80,791] → 81,177 ops/sec [78,488..98,389]	~ overlap (+1.0%)
mixed text and expression	81,488 ops/sec [68,164..85,322] → 66,243 ops/sec [63,232..70,374]	~ overlap (-18.7%)	88,641 ops/sec [71,113..122,757] → 73,812 ops/sec [72,269..108,051]	~ overlap (-16.7%)
nested elements (3 levels)	30,031 ops/sec [29,805..31,789] → 35,201 ops/sec [29,363..37,324]	~ overlap (+17.2%)	32,931 ops/sec [32,202..44,893] → 37,058 ops/sec [32,235..49,334]	~ overlap (+12.5%)
sibling children	23,051 ops/sec [22,259..26,668] → 22,265 ops/sec [21,894..22,867]	~ overlap (-3.4%)	25,357 ops/sec [23,442..36,716] → 23,899 ops/sec [23,750..31,892]	~ overlap (-5.8%)
component element	55,311 ops/sec [53,957..64,833] → 57,210 ops/sec [52,501..61,470]	~ overlap (+3.4%)	69,828 ops/sec [60,874..75,270] → 67,160 ops/sec [65,716..82,625]	~ overlap (-3.8%)
component with children	34,734 ops/sec [34,597..54,878] → 41,362 ops/sec [34,399..42,683]	~ overlap (+19.1%)	37,837 ops/sec [37,664..54,590] → 42,121 ops/sec [41,269..42,483]	~ overlap (+11.3%)
dotted component	48,608 ops/sec [46,326..74,675] → 46,831 ops/sec [46,683..47,823]	~ overlap (-3.7%)	50,575 ops/sec [50,233..56,403] → 50,816 ops/sec [49,692..79,215]	~ overlap (+0.5%)
empty fragment	78,454 ops/sec [77,276..78,965] → 78,791 ops/sec [78,424..79,856]	~ overlap (+0.4%)	94,372 ops/sec [93,030..105,602] → 94,352 ops/sec [93,561..99,675]	~ overlap (-0.0%)
fragment with children	26,921 ops/sec [22,604..30,181] → 22,242 ops/sec [21,657..26,455]	~ overlap (-17.4%)	24,069 ops/sec [23,762..28,732] → 24,721 ops/sec [23,967..31,404]	~ overlap (+2.7%)
spread attributes	38,493 ops/sec [38,199..39,491] → 38,145 ops/sec [33,612..39,124]	~ overlap (-0.9%)	37,462 ops/sec [37,186..42,371] → 36,029 ops/sec [34,672..38,658]	~ overlap (-3.8%)
spread with overrides	38,837 ops/sec [33,484..41,257] → 34,538 ops/sec [34,294..34,974]	~ overlap (-11.1%)	33,205 ops/sec [31,189..33,531] → 32,932 ops/sec [31,103..33,191]	~ overlap (-0.8%)
shorthand props	59,566 ops/sec [57,264..59,903] → 56,833 ops/sec [56,435..62,165]	~ overlap (-4.6%)	54,835 ops/sec [52,049..61,166] → 56,276 ops/sec [55,664..56,442]	~ overlap (+2.6%)
nav bar structure	12,749 ops/sec [11,126..13,712] → 11,018 ops/sec [10,729..11,352]	~ overlap (-13.6%)	10,703 ops/sec [10,650..11,016] → 11,419 ops/sec [11,369..11,550]	🟢 +6.7%
card component tree	14,629 ops/sec [14,372..14,841] → 12,822 ops/sec [12,696..14,232]	🔴 -12.4%	12,526 ops/sec [12,170..12,844] → 12,788 ops/sec [12,566..13,114]	~ overlap (+2.1%)
10 list items via Array.from	5,669 ops/sec [5,593..6,096] → 5,831 ops/sec [5,525..6,557]	~ overlap (+2.9%)	5,183 ops/sec [5,139..5,430] → 5,341 ops/sec [5,301..5,371]	~ overlap (+3.1%)

modules.js — Interp: 🔴 2, 7 unch. · avg -4.9% · Bytecode: 🟢 1, 8 unch. · avg +1.5%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
call imported function	127,585 ops/sec [124,438..146,757] → 134,703 ops/sec [125,055..144,795]	~ overlap (+5.6%)	45,500 ops/sec [44,170..46,001] → 45,405 ops/sec [44,994..45,926]	~ overlap (-0.2%)
call two imported functions	74,508 ops/sec [71,190..80,426] → 70,258 ops/sec [66,632..71,886]	~ overlap (-5.7%)	23,443 ops/sec [23,174..26,158] → 23,084 ops/sec [21,739..23,573]	~ overlap (-1.5%)
read imported constant	348,081 ops/sec [331,671..413,181] → 316,606 ops/sec [308,402..322,263]	🔴 -9.0%	49,076 ops/sec [48,988..50,283] → 51,250 ops/sec [47,446..57,804]	~ overlap (+4.4%)
read imported string	371,900 ops/sec [323,838..491,635] → 319,085 ops/sec [301,337..349,644]	~ overlap (-14.2%)	47,340 ops/sec [46,789..49,785] → 53,134 ops/sec [46,070..64,294]	~ overlap (+12.2%)
read JSON string property	345,334 ops/sec [337,983..357,903] → 329,278 ops/sec [298,652..359,239]	~ overlap (-4.6%)	54,208 ops/sec [47,201..63,313] → 48,687 ops/sec [48,108..56,336]	~ overlap (-10.2%)
read JSON number property	351,858 ops/sec [341,236..386,910] → 337,110 ops/sec [332,125..348,887]	~ overlap (-4.2%)	51,044 ops/sec [48,828..54,394] → 48,639 ops/sec [47,193..50,186]	~ overlap (-4.7%)
read JSON boolean property	361,602 ops/sec [339,449..384,047] → 327,753 ops/sec [324,991..334,158]	🔴 -9.4%	50,360 ops/sec [49,863..61,592] → 52,293 ops/sec [49,013..54,758]	~ overlap (+3.8%)
read JSON array property	330,515 ops/sec [328,428..338,929] → 332,179 ops/sec [314,170..383,469]	~ overlap (+0.5%)	50,642 ops/sec [49,895..51,828] → 55,553 ops/sec [54,646..58,705]	🟢 +9.7%
read multiple JSON properties	197,399 ops/sec [193,107..200,135] → 191,003 ops/sec [182,545..195,994]	~ overlap (-3.2%)	17,058 ops/sec [16,846..17,686] → 17,023 ops/sec [16,909..17,185]	~ overlap (-0.2%)

numbers.js — Interp: 🟢 1, 11 unch. · avg +0.9% · Bytecode: 🟢 4, 8 unch. · avg +5.2%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
integer arithmetic	94,268 ops/sec [93,724..98,404] → 94,218 ops/sec [90,680..113,855]	~ overlap (-0.1%)	355,252 ops/sec [353,562..357,901] → 368,451 ops/sec [367,780..372,419]	🟢 +3.7%
floating point arithmetic	113,907 ops/sec [111,341..115,249] → 111,764 ops/sec [111,358..116,588]	~ overlap (-1.9%)	206,513 ops/sec [205,702..206,631] → 208,091 ops/sec [207,867..213,107]	🟢 +0.8%
number coercion	41,694 ops/sec [40,733..43,991] → 45,922 ops/sec [42,001..55,143]	~ overlap (+10.1%)	59,327 ops/sec [59,199..59,870] → 62,057 ops/sec [58,850..64,339]	~ overlap (+4.6%)
toFixed	34,141 ops/sec [33,336..34,532] → 37,245 ops/sec [35,770..37,482]	🟢 +9.1%	36,247 ops/sec [36,123..36,325] → 38,571 ops/sec [38,193..38,673]	🟢 +6.4%
toString	49,006 ops/sec [48,876..49,161] → 51,285 ops/sec [47,701..52,764]	~ overlap (+4.6%)	61,130 ops/sec [60,869..61,337] → 78,360 ops/sec [74,181..78,605]	🟢 +28.2%
toString non-integer (shortest round-trip)	5,504 ops/sec [5,437..5,735] → 5,582 ops/sec [5,481..6,288]	~ overlap (+1.4%)	7,338 ops/sec [7,025..7,840] → 7,187 ops/sec [6,986..7,517]	~ overlap (-2.1%)
valueOf	75,088 ops/sec [69,719..89,909] → 75,709 ops/sec [68,709..85,518]	~ overlap (+0.8%)	91,642 ops/sec [84,833..124,838] → 91,362 ops/sec [88,732..92,507]	~ overlap (-0.3%)
toPrecision	24,967 ops/sec [24,454..25,163] → 24,868 ops/sec [23,811..27,648]	~ overlap (-0.4%)	26,264 ops/sec [25,481..26,340] → 26,654 ops/sec [26,317..26,744]	~ overlap (+1.5%)
Number.isNaN	77,972 ops/sec [73,546..81,886] → 76,465 ops/sec [76,156..79,887]	~ overlap (-1.9%)	101,481 ops/sec [97,850..102,679] → 111,610 ops/sec [99,367..131,858]	~ overlap (+10.0%)
Number.isFinite	85,460 ops/sec [73,697..95,465] → 80,909 ops/sec [77,084..89,938]	~ overlap (-5.3%)	90,322 ops/sec [89,995..91,260] → 92,201 ops/sec [88,071..93,358]	~ overlap (+2.1%)
Number.isInteger	86,681 ops/sec [78,224..89,172] → 79,920 ops/sec [77,337..80,417]	~ overlap (-7.8%)	99,319 ops/sec [98,073..99,701] → 108,442 ops/sec [85,449..115,477]	~ overlap (+9.2%)
Number.parseInt and parseFloat	65,539 ops/sec [63,892..94,815] → 66,692 ops/sec [63,305..68,384]	~ overlap (+1.8%)	75,122 ops/sec [73,559..76,239] → 74,090 ops/sec [71,807..74,267]	~ overlap (-1.4%)

objects.js — Interp: 🟢 1, 6 unch. · avg -0.0% · Bytecode: 🟢 3, 4 unch. · avg +7.1%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
create simple object	150,415 ops/sec [144,879..180,954] → 148,112 ops/sec [144,185..178,669]	~ overlap (-1.5%)	127,490 ops/sec [126,917..128,132] → 146,017 ops/sec [133,966..148,247]	🟢 +14.5%
create nested object	82,323 ops/sec [81,100..82,984] → 90,545 ops/sec [83,467..109,048]	🟢 +10.0%	59,964 ops/sec [59,659..60,192] → 62,411 ops/sec [59,378..82,456]	~ overlap (+4.1%)
create 50 objects via Array.from	3,428 ops/sec [3,252..3,803] → 3,240 ops/sec [3,130..3,348]	~ overlap (-5.5%)	2,315 ops/sec [2,302..2,335] → 2,510 ops/sec [2,422..3,880]	🟢 +8.4%
property read	136,406 ops/sec [130,975..212,527] → 127,507 ops/sec [125,777..135,490]	~ overlap (-6.5%)	286,575 ops/sec [257,790..290,020] → 299,632 ops/sec [291,959..322,991]	🟢 +4.6%
Object.keys	91,010 ops/sec [83,544..124,070] → 95,488 ops/sec [80,077..98,391]	~ overlap (+4.9%)	93,882 ops/sec [93,309..98,484] → 98,350 ops/sec [95,841..116,923]	~ overlap (+4.8%)
Object.entries	41,132 ops/sec [40,668..44,364] → 40,302 ops/sec [37,795..56,526]	~ overlap (-2.0%)	43,072 ops/sec [41,820..51,354] → 44,718 ops/sec [43,687..44,999]	~ overlap (+3.8%)
spread operator	58,096 ops/sec [52,524..81,114] → 58,479 ops/sec [51,783..73,870]	~ overlap (+0.7%)	53,262 ops/sec [51,277..79,811] → 58,230 ops/sec [50,264..74,816]	~ overlap (+9.3%)

promises.js — Interp: 🔴 1, 11 unch. · avg -4.1% · Bytecode: 🟢 3, 🔴 1, 8 unch. · avg +0.6%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
Promise.resolve(value)	75,047 ops/sec [67,071..76,378] → 68,495 ops/sec [65,765..87,901]	~ overlap (-8.7%)	77,001 ops/sec [76,362..92,480] → 102,092 ops/sec [98,437..106,101]	🟢 +32.6%
new Promise(resolve => resolve(value))	58,183 ops/sec [50,950..59,709] → 49,944 ops/sec [49,144..66,269]	~ overlap (-14.2%)	66,745 ops/sec [59,416..78,142] → 61,965 ops/sec [55,258..75,255]	~ overlap (-7.2%)
Promise.reject(reason)	71,651 ops/sec [69,524..88,555] → 77,466 ops/sec [68,619..103,945]	~ overlap (+8.1%)	86,899 ops/sec [79,698..103,745] → 77,298 ops/sec [76,466..88,700]	~ overlap (-11.0%)
resolve + then (1 handler)	22,915 ops/sec [22,643..25,620] → 25,361 ops/sec [22,716..27,786]	~ overlap (+10.7%)	29,499 ops/sec [25,386..31,093] → 26,604 ops/sec [24,682..29,630]	~ overlap (-9.8%)
resolve + then chain (3 deep)	10,309 ops/sec [9,403..11,381] → 9,500 ops/sec [9,334..9,646]	~ overlap (-7.8%)	10,746 ops/sec [10,720..10,813] → 11,515 ops/sec [10,917..12,126]	🟢 +7.2%
resolve + then chain (10 deep)	3,323 ops/sec [3,167..3,638] → 3,152 ops/sec [3,144..3,288]	~ overlap (-5.1%)	3,521 ops/sec [3,504..3,526] → 3,514 ops/sec [3,485..3,642]	~ overlap (-0.2%)
reject + catch + then	13,528 ops/sec [13,204..16,056] → 13,358 ops/sec [13,111..15,755]	~ overlap (-1.3%)	14,468 ops/sec [14,353..14,541] → 15,014 ops/sec [14,588..16,559]	🟢 +3.8%
resolve + finally + then	7,276 ops/sec [6,315..9,434] → 6,326 ops/sec [6,277..7,221]	~ overlap (-13.1%)	7,278 ops/sec [6,887..8,650] → 7,089 ops/sec [7,023..7,114]	~ overlap (-2.6%)
Promise.all (5 resolved)	4,580 ops/sec [4,332..4,721] → 5,240 ops/sec [3,640..7,141]	~ overlap (+14.4%)	4,919 ops/sec [4,891..4,953] → 4,487 ops/sec [4,437..4,513]	🔴 -8.8%
Promise.race (5 resolved)	5,813 ops/sec [5,193..6,675] → 5,082 ops/sec [4,935..5,439]	~ overlap (-12.6%)	5,596 ops/sec [5,162..6,384] → 5,501 ops/sec [5,234..6,625]	~ overlap (-1.7%)
Promise.allSettled (5 mixed)	4,046 ops/sec [3,781..4,985] → 3,857 ops/sec [3,694..4,337]	~ overlap (-4.7%)	4,035 ops/sec [3,819..4,249] → 4,465 ops/sec [3,955..4,869]	~ overlap (+10.7%)
Promise.any (5 mixed)	5,172 ops/sec [4,597..5,804] → 4,425 ops/sec [4,358..4,573]	🔴 -14.4%	4,864 ops/sec [4,713..6,475] → 4,579 ops/sec [4,543..5,125]	~ overlap (-5.9%)

property-access.js — Interp: 5 unch. · avg -2.7% · Bytecode: 5 unch. · avg +2.9%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
class instance fields across 1000 instances	148 ops/sec [138..215] → 146 ops/sec [136..150]	~ overlap (-0.9%)	721 ops/sec [692..781] → 683 ops/sec [664..725]	~ overlap (-5.3%)
object literal fields across 1000 literals	147 ops/sec [136..232] → 141 ops/sec [134..148]	~ overlap (-4.2%)	654 ops/sec [650..838] → 695 ops/sec [678..729]	~ overlap (+6.3%)
mixed-shape literals across 1000 literals	162 ops/sec [140..173] → 141 ops/sec [133..223]	~ overlap (-12.7%)	517 ops/sec [510..524] → 532 ops/sec [523..612]	~ overlap (+2.9%)
own-class method across 1000 instances	86 ops/sec [82..91] → 84 ops/sec [83..90]	~ overlap (-1.4%)	334 ops/sec [330..388] → 339 ops/sec [328..346]	~ overlap (+1.6%)
inherited method across 1000 instances	91 ops/sec [90..93] → 96 ops/sec [93..143]	~ overlap (+5.6%)	398 ops/sec [380..421] → 433 ops/sec [380..484]	~ overlap (+8.7%)

regexp.js — Interp: 11 unch. · avg +0.2% · Bytecode: 🟢 1, 10 unch. · avg +0.8%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
regex literal creation	7,151 ops/sec [6,626..8,175] → 7,685 ops/sec [7,015..9,692]	~ overlap (+7.5%)	185,454 ops/sec [184,893..192,117] → 187,953 ops/sec [186,563..195,745]	~ overlap (+1.3%)
new RegExp(pattern, flags)	6,592 ops/sec [6,465..6,941] → 6,805 ops/sec [6,449..8,595]	~ overlap (+3.2%)	7,063 ops/sec [6,752..7,137] → 6,808 ops/sec [6,692..6,838]	~ overlap (-3.6%)
RegExp(existingRegex) returns the same regex	174,923 ops/sec [170,712..176,865] → 183,336 ops/sec [171,881..225,564]	~ overlap (+4.8%)	273,687 ops/sec [267,042..345,957] → 269,649 ops/sec [261,995..275,455]	~ overlap (-1.5%)
test() on a global regex	57,114 ops/sec [54,204..72,883] → 58,998 ops/sec [53,759..65,481]	~ overlap (+3.3%)	74,311 ops/sec [74,025..74,404] → 74,195 ops/sec [71,824..80,231]	~ overlap (-0.2%)
exec() with capture groups	15,601 ops/sec [15,142..16,168] → 15,637 ops/sec [14,995..16,572]	~ overlap (+0.2%)	16,537 ops/sec [16,377..16,596] → 17,084 ops/sec [16,820..17,749]	🟢 +3.3%
toString()	151,717 ops/sec [145,544..173,386] → 150,995 ops/sec [145,155..221,262]	~ overlap (-0.5%)	226,706 ops/sec [220,420..264,349] → 257,153 ops/sec [220,463..297,825]	~ overlap (+13.4%)
match() with global regex	21,088 ops/sec [20,361..28,809] → 20,385 ops/sec [20,097..20,449]	~ overlap (-3.3%)	23,728 ops/sec [22,541..24,894] → 22,715 ops/sec [22,169..28,436]	~ overlap (-4.3%)
matchAll() with capture groups	11,241 ops/sec [9,471..12,879] → 9,635 ops/sec [9,580..10,995]	~ overlap (-14.3%)	13,865 ops/sec [13,622..16,206] → 14,004 ops/sec [13,775..14,197]	~ overlap (+1.0%)
replace() with global regex	18,186 ops/sec [17,936..21,473] → 18,485 ops/sec [18,096..18,683]	~ overlap (+1.6%)	19,972 ops/sec [19,594..20,227] → 20,027 ops/sec [19,402..21,322]	~ overlap (+0.3%)
search() with regex	39,553 ops/sec [39,120..40,086] → 40,223 ops/sec [37,379..42,036]	~ overlap (+1.7%)	47,496 ops/sec [47,346..55,083] → 47,425 ops/sec [47,051..53,472]	~ overlap (-0.1%)
split() with regex separator	7,347 ops/sec [7,169..7,387] → 7,164 ops/sec [7,144..7,198]	~ overlap (-2.5%)	7,854 ops/sec [7,598..9,369] → 7,755 ops/sec [7,725..7,898]	~ overlap (-1.3%)

strings.js — Interp: 🟢 1, 18 unch. · avg +0.8% · Bytecode: 🟢 1, 18 unch. · avg +0.3%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
string concatenation	122,987 ops/sec [106,194..139,620] → 117,594 ops/sec [116,463..138,773]	~ overlap (-4.4%)	494,960 ops/sec [492,927..498,611] → 499,864 ops/sec [481,423..584,609]	~ overlap (+1.0%)
template literal	196,042 ops/sec [195,192..199,096] → 209,487 ops/sec [197,688..216,470]	~ overlap (+6.9%)	404,107 ops/sec [401,634..405,507] → 380,702 ops/sec [373,772..421,205]	~ overlap (-5.8%)
string repeat	129,458 ops/sec [128,825..148,149] → 131,964 ops/sec [130,399..132,949]	~ overlap (+1.9%)	168,925 ops/sec [165,620..189,356] → 163,942 ops/sec [162,731..165,848]	~ overlap (-2.9%)
split and join	54,476 ops/sec [47,022..65,077] → 47,010 ops/sec [46,742..51,620]	~ overlap (-13.7%)	55,708 ops/sec [53,754..58,755] → 55,431 ops/sec [52,032..64,007]	~ overlap (-0.5%)
indexOf and includes	57,836 ops/sec [51,821..63,357] → 51,945 ops/sec [49,128..60,557]	~ overlap (-10.2%)	56,984 ops/sec [55,257..64,047] → 58,816 ops/sec [57,850..58,887]	~ overlap (+3.2%)
toUpperCase and toLowerCase	67,375 ops/sec [64,774..75,548] → 67,486 ops/sec [66,305..67,781]	~ overlap (+0.2%)	79,081 ops/sec [76,819..83,842] → 79,886 ops/sec [78,664..81,118]	~ overlap (+1.0%)
slice and substring	49,758 ops/sec [48,260..55,004] → 49,183 ops/sec [47,232..50,388]	~ overlap (-1.2%)	62,745 ops/sec [61,110..63,356] → 63,523 ops/sec [62,959..63,755]	~ overlap (+1.2%)
trim operations	58,412 ops/sec [57,280..58,757] → 57,773 ops/sec [57,486..57,956]	~ overlap (-1.1%)	71,499 ops/sec [70,812..72,156] → 70,184 ops/sec [69,331..72,104]	~ overlap (-1.8%)
replace and replaceAll	58,145 ops/sec [55,831..58,697] → 57,487 ops/sec [56,121..58,683]	~ overlap (-1.1%)	61,217 ops/sec [60,882..61,290] → 61,456 ops/sec [61,172..62,079]	~ overlap (+0.4%)
startsWith and endsWith	42,517 ops/sec [40,873..48,399] → 41,231 ops/sec [40,946..45,647]	~ overlap (-3.0%)	47,467 ops/sec [44,470..53,394] → 46,239 ops/sec [44,891..46,714]	~ overlap (-2.6%)
padStart and padEnd	63,118 ops/sec [61,320..74,907] → 73,313 ops/sec [64,033..79,296]	~ overlap (+16.2%)	72,236 ops/sec [70,160..75,412] → 74,105 ops/sec [72,239..77,825]	~ overlap (+2.6%)
identity tag, no substitutions	104,918 ops/sec [101,460..105,741] → 118,789 ops/sec [103,322..122,634]	~ overlap (+13.2%)	157,280 ops/sec [156,927..157,631] → 162,283 ops/sec [154,419..172,018]	~ overlap (+3.2%)
tag with 1 substitution	24,848 ops/sec [24,522..25,083] → 25,036 ops/sec [24,381..27,168]	~ overlap (+0.8%)	31,247 ops/sec [30,559..31,959] → 31,604 ops/sec [30,486..31,911]	~ overlap (+1.1%)
tag with 3 substitutions	14,062 ops/sec [13,822..16,683] → 13,833 ops/sec [13,617..13,938]	~ overlap (-1.6%)	18,490 ops/sec [18,362..18,565] → 18,755 ops/sec [18,632..18,911]	🟢 +1.4%
tag with 6 substitutions	8,306 ops/sec [8,149..9,016] → 8,501 ops/sec [8,277..9,498]	~ overlap (+2.3%)	11,838 ops/sec [11,728..12,153] → 11,770 ops/sec [11,672..11,901]	~ overlap (-0.6%)
String.raw, no substitutions	84,106 ops/sec [83,521..85,263] → 86,986 ops/sec [85,938..90,606]	🟢 +3.4%	88,680 ops/sec [85,487..88,923] → 87,480 ops/sec [85,970..87,873]	~ overlap (-1.4%)
String.raw, 2 substitutions	67,650 ops/sec [65,790..70,679] → 68,986 ops/sec [67,884..69,886]	~ overlap (+2.0%)	69,612 ops/sec [69,036..70,638] → 70,550 ops/sec [70,072..71,146]	~ overlap (+1.3%)
tag accessing .raw array	39,152 ops/sec [38,636..39,910] → 39,891 ops/sec [39,609..39,995]	~ overlap (+1.9%)	44,966 ops/sec [44,321..48,099] → 45,895 ops/sec [42,284..48,885]	~ overlap (+2.1%)
method as tag (this binding)	16,659 ops/sec [16,358..16,761] → 17,219 ops/sec [16,414..18,752]	~ overlap (+3.4%)	21,719 ops/sec [21,651..22,202] → 22,147 ops/sec [21,980..22,232]	~ overlap (+2.0%)

temporal.js — Interp: 6 unch. · avg -0.7% · Bytecode: 6 unch. · avg +2.3%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
PlainDate.add({ months: 1 })	46,195 ops/sec [42,354..48,791] → 41,963 ops/sec [40,387..43,687]	~ overlap (-9.2%)	45,406 ops/sec [44,654..51,157] → 46,364 ops/sec [44,914..49,112]	~ overlap (+2.1%)
PlainDate.until(..., { largestUnit: 'months' })	51,849 ops/sec [50,370..52,456] → 54,177 ops/sec [49,010..57,949]	~ overlap (+4.5%)	54,679 ops/sec [53,420..63,979] → 55,512 ops/sec [54,034..73,795]	~ overlap (+1.5%)
Duration.total days relative to PlainDate	47,189 ops/sec [44,775..51,608] → 47,334 ops/sec [46,731..47,536]	~ overlap (+0.3%)	45,481 ops/sec [43,942..72,724] → 46,105 ops/sec [44,714..46,829]	~ overlap (+1.4%)
Duration.round to hours	34,241 ops/sec [32,397..34,416] → 35,313 ops/sec [32,831..41,944]	~ overlap (+3.1%)	33,301 ops/sec [32,639..34,137] → 32,576 ops/sec [32,179..34,199]	~ overlap (-2.2%)
ZonedDateTime.from named time zone	10,157 ops/sec [9,763..10,819] → 10,064 ops/sec [9,969..11,583]	~ overlap (-0.9%)	10,339 ops/sec [9,607..11,017] → 10,834 ops/sec [10,256..10,889]	~ overlap (+4.8%)
ZonedDateTime.since across DST	9,868 ops/sec [9,714..9,904] → 9,649 ops/sec [9,490..11,938]	~ overlap (-2.2%)	10,446 ops/sec [9,843..11,851] → 11,079 ops/sec [10,210..11,384]	~ overlap (+6.1%)

tsv.js — Interp: 🔴 3, 6 unch. · avg -5.3% · Bytecode: 🔴 1, 8 unch. · avg -1.6%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
parse simple 3-column TSV	41,553 ops/sec [40,543..44,112] → 37,772 ops/sec [37,378..39,276]	🔴 -9.1%	43,690 ops/sec [43,354..44,554] → 44,142 ops/sec [42,995..51,114]	~ overlap (+1.0%)
parse 10-row TSV	11,527 ops/sec [11,455..11,820] → 10,760 ops/sec [10,555..11,083]	🔴 -6.7%	11,803 ops/sec [11,714..13,384] → 11,826 ops/sec [11,627..12,507]	~ overlap (+0.2%)
parse 100-row TSV	1,858 ops/sec [1,846..2,135] → 1,747 ops/sec [1,692..2,300]	~ overlap (-6.0%)	2,012 ops/sec [1,901..2,112] → 1,830 ops/sec [1,826..1,831]	🔴 -9.1%
parse TSV with backslash-escaped fields	10,947 ops/sec [9,371..11,639] → 8,307 ops/sec [8,117..8,363]	🔴 -24.1%	8,969 ops/sec [8,907..9,821] → 9,624 ops/sec [8,829..10,881]	~ overlap (+7.3%)
parse without headers (array of arrays)	5,676 ops/sec [5,587..7,652] → 5,392 ops/sec [5,366..7,085]	~ overlap (-5.0%)	6,891 ops/sec [5,549..8,235] → 6,291 ops/sec [5,533..6,852]	~ overlap (-8.7%)
stringify array of objects	35,069 ops/sec [34,162..38,631] → 34,655 ops/sec [33,415..37,257]	~ overlap (-1.2%)	40,231 ops/sec [38,544..46,054] → 38,920 ops/sec [37,780..43,037]	~ overlap (-3.3%)
stringify array of arrays	11,247 ops/sec [11,051..12,216] → 11,845 ops/sec [10,412..12,518]	~ overlap (+5.3%)	11,631 ops/sec [11,128..13,164] → 11,114 ops/sec [10,941..11,204]	~ overlap (-4.5%)
stringify with values needing escaping	30,407 ops/sec [27,854..33,980] → 31,507 ops/sec [28,843..35,539]	~ overlap (+3.6%)	30,842 ops/sec [30,327..39,992] → 31,098 ops/sec [30,416..37,187]	~ overlap (+0.8%)
parse then stringify	6,579 ops/sec [6,357..10,713] → 6,277 ops/sec [6,253..8,045]	~ overlap (-4.6%)	6,620 ops/sec [6,368..7,321] → 6,716 ops/sec [6,685..7,933]	~ overlap (+1.5%)

typed-arrays.js — Interp: 🟢 2, 🔴 5, 15 unch. · avg -5.7% · Bytecode: 🟢 4, 🔴 3, 15 unch. · avg +9.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
new Int32Array(0)	92,657 ops/sec [91,491..93,377] → 90,934 ops/sec [88,237..119,227]	~ overlap (-1.9%)	123,803 ops/sec [120,910..125,552] → 114,475 ops/sec [109,428..120,109]	🔴 -7.5%
new Int32Array(100)	87,383 ops/sec [85,282..104,141] → 86,859 ops/sec [84,342..91,185]	~ overlap (-0.6%)	104,461 ops/sec [102,927..105,396] → 104,794 ops/sec [103,821..106,077]	~ overlap (+0.3%)
new Int32Array(1000)	70,391 ops/sec [69,678..71,109] → 70,423 ops/sec [69,914..77,130]	~ overlap (+0.0%)	82,169 ops/sec [81,596..82,657] → 79,627 ops/sec [78,259..96,787]	~ overlap (-3.1%)
new Float64Array(100)	86,339 ops/sec [85,128..87,926] → 86,276 ops/sec [85,637..86,579]	~ overlap (-0.1%)	102,268 ops/sec [101,531..102,778] → 100,202 ops/sec [98,975..157,045]	~ overlap (-2.0%)
Int32Array.from([...])	1,741 ops/sec [1,543..1,803] → 1,503 ops/sec [1,474..1,648]	~ overlap (-13.7%)	1,572 ops/sec [1,483..1,642] → 1,498 ops/sec [1,436..2,384]	~ overlap (-4.7%)
Int32Array.of(1, 2, 3, 4, 5)	69,694 ops/sec [67,711..80,310] → 69,135 ops/sec [66,273..75,331]	~ overlap (-0.8%)	77,976 ops/sec [77,204..78,255] → 80,115 ops/sec [78,755..83,265]	🟢 +2.7%
sequential write 100 elements	1,049 ops/sec [1,014..1,064] → 1,038 ops/sec [1,023..1,053]	~ overlap (-1.1%)	5,037 ops/sec [4,985..5,230] → 5,278 ops/sec [5,084..5,350]	~ overlap (+4.8%)
sequential read 100 elements	1,143 ops/sec [1,114..1,170] → 1,158 ops/sec [1,112..1,338]	~ overlap (+1.3%)	6,597 ops/sec [6,478..6,607] → 6,631 ops/sec [6,550..6,683]	~ overlap (+0.5%)
Float64Array write 100 elements	990 ops/sec [977..1,021] → 997 ops/sec [986..1,028]	~ overlap (+0.6%)	4,264 ops/sec [4,133..4,402] → 4,193 ops/sec [4,099..4,300]	~ overlap (-1.7%)
fill(42)	2,181 ops/sec [2,140..2,190] → 2,313 ops/sec [2,195..2,509]	🟢 +6.1%	2,211 ops/sec [2,174..2,216] → 2,185 ops/sec [2,171..2,310]	~ overlap (-1.2%)
slice()	8,772 ops/sec [8,727..8,798] → 8,615 ops/sec [8,586..8,880]	~ overlap (-1.8%)	9,000 ops/sec [8,983..9,437] → 8,870 ops/sec [8,784..9,077]	~ overlap (-1.4%)
map(x => x * 2)	1,985 ops/sec [1,922..2,113] → 2,005 ops/sec [1,964..2,191]	~ overlap (+1.0%)	2,180 ops/sec [2,164..2,183] → 2,184 ops/sec [2,079..2,189]	~ overlap (+0.1%)
filter(x => x > 50)	3,469 ops/sec [3,438..3,475] → 2,070 ops/sec [2,036..2,104]	🔴 -40.3%	3,566 ops/sec [2,274..3,886] → 3,955 ops/sec [3,921..3,977]	🟢 +10.9%
reduce (sum)	3,530 ops/sec [3,513..3,533] → 2,135 ops/sec [2,123..2,143]	🔴 -39.5%	3,639 ops/sec [3,623..3,660] → 3,625 ops/sec [3,608..3,637]	~ overlap (-0.4%)
sort()	22,887 ops/sec [13,326..23,183] → 23,086 ops/sec [13,565..23,152]	~ overlap (+0.9%)	14,083 ops/sec [13,865..24,035] → 23,843 ops/sec [23,730..24,051]	~ overlap (+69.3%)
indexOf()	49,732 ops/sec [49,216..50,163] → 48,578 ops/sec [28,564..48,970]	🔴 -2.3%	31,332 ops/sec [31,262..32,608] → 51,341 ops/sec [50,759..51,755]	🟢 +63.9%
reverse()	26,049 ops/sec [25,901..26,166] → 26,135 ops/sec [25,710..26,234]	~ overlap (+0.3%)	15,577 ops/sec [15,365..15,649] → 27,132 ops/sec [27,052..27,196]	🟢 +74.2%
create view over existing buffer	162,704 ops/sec [157,692..164,651] → 110,350 ops/sec [99,909..118,853]	🔴 -32.2%	202,198 ops/sec [200,749..204,019] → 200,769 ops/sec [198,375..201,734]	~ overlap (-0.7%)
subarray()	109,382 ops/sec [108,787..109,650] → 108,580 ops/sec [108,136..109,041]	~ overlap (-0.7%)	124,000 ops/sec [123,205..124,243] → 122,931 ops/sec [121,509..123,937]	~ overlap (-0.9%)
set() from array	127,723 ops/sec [127,371..128,857] → 127,162 ops/sec [76,017..128,345]	~ overlap (-0.4%)	159,327 ops/sec [158,606..159,374] → 156,802 ops/sec [156,229..158,007]	🔴 -1.6%
for-of loop	2,461 ops/sec [2,455..2,466] → 2,484 ops/sec [2,475..2,508]	🟢 +0.9%	13,032 ops/sec [12,914..13,084] → 12,982 ops/sec [12,902..13,042]	~ overlap (-0.4%)
spread into array	10,645 ops/sec [10,561..10,685] → 10,413 ops/sec [10,354..10,444]	🔴 -2.2%	40,967 ops/sec [40,489..41,434] → 39,727 ops/sec [39,268..39,902]	🔴 -3.0%

uint8array-encoding.js — Interp: 🟢 6, 12 unch. · avg +17.8% · Bytecode: 🟢 1, 🔴 2, 15 unch. · avg +0.0%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
short (5 bytes)	138,861 ops/sec [129,131..150,858] → 141,184 ops/sec [134,683..147,537]	~ overlap (+1.7%)	192,896 ops/sec [183,386..207,435] → 186,866 ops/sec [184,476..244,200]	~ overlap (-3.1%)
medium (450 bytes)	97,688 ops/sec [94,746..98,978] → 101,054 ops/sec [99,333..103,091]	🟢 +3.4%	120,169 ops/sec [119,038..121,012] → 119,260 ops/sec [117,337..122,730]	~ overlap (-0.8%)
large (4096 bytes)	28,669 ops/sec [28,037..31,271] → 28,740 ops/sec [28,621..28,889]	~ overlap (+0.2%)	31,187 ops/sec [29,926..32,542] → 30,615 ops/sec [30,276..30,703]	~ overlap (-1.8%)
base64url alphabet	73,260 ops/sec [71,358..73,416] → 75,268 ops/sec [73,935..76,204]	🟢 +2.7%	79,489 ops/sec [78,608..79,994] → 77,591 ops/sec [76,896..87,846]	~ overlap (-2.4%)
omitPadding	98,240 ops/sec [95,242..115,162] → 98,490 ops/sec [97,128..115,245]	~ overlap (+0.3%)	106,491 ops/sec [104,245..147,078] → 109,825 ops/sec [107,042..131,200]	~ overlap (+3.1%)
short (8 chars)	109,710 ops/sec [107,286..116,894] → 110,829 ops/sec [109,194..116,772]	~ overlap (+1.0%)	129,970 ops/sec [128,282..133,155] → 134,123 ops/sec [131,094..140,731]	~ overlap (+3.2%)
medium (600 chars)	60,272 ops/sec [59,140..79,136] → 61,112 ops/sec [57,817..61,919]	~ overlap (+1.4%)	66,490 ops/sec [65,396..69,507] → 66,048 ops/sec [65,585..67,372]	~ overlap (-0.7%)
large (5464 chars)	13,087 ops/sec [12,811..14,226] → 12,838 ops/sec [12,605..13,467]	~ overlap (-1.9%)	13,250 ops/sec [13,041..13,497] → 14,318 ops/sec [13,031..15,687]	~ overlap (+8.1%)
short (5 bytes)	140,975 ops/sec [140,266..142,390] → 141,571 ops/sec [140,987..142,150]	~ overlap (+0.4%)	201,656 ops/sec [199,438..203,504] → 199,713 ops/sec [197,182..215,687]	~ overlap (-1.0%)
medium (450 bytes)	90,100 ops/sec [85,779..99,097] → 144,062 ops/sec [142,598..144,237]	🟢 +59.9%	108,683 ops/sec [104,870..116,557] → 106,002 ops/sec [104,864..106,321]	~ overlap (-2.5%)
large (4096 bytes)	21,352 ops/sec [20,813..22,929] → 35,401 ops/sec [21,347..35,696]	~ overlap (+65.8%)	22,845 ops/sec [22,135..23,003] → 23,054 ops/sec [22,405..23,888]	~ overlap (+0.9%)
short (10 chars)	117,021 ops/sec [115,670..121,388] → 120,822 ops/sec [119,917..123,337]	~ overlap (+3.2%)	145,555 ops/sec [143,234..147,248] → 160,491 ops/sec [155,486..163,951]	🟢 +10.3%
medium (900 chars)	86,450 ops/sec [85,425..87,316] → 142,637 ops/sec [140,999..143,197]	🟢 +65.0%	105,311 ops/sec [104,168..123,184] → 100,405 ops/sec [99,784..111,668]	~ overlap (-4.7%)
large (8192 chars)	30,138 ops/sec [28,530..31,976] → 30,080 ops/sec [28,091..30,673]	~ overlap (-0.2%)	27,547 ops/sec [27,134..28,074] → 27,811 ops/sec [27,020..28,570]	~ overlap (+1.0%)
setFromBase64 (450 bytes)	52,468 ops/sec [51,979..55,755] → 86,631 ops/sec [85,877..86,931]	🟢 +65.1%	59,852 ops/sec [59,290..60,980] → 59,825 ops/sec [59,311..60,164]	~ overlap (-0.0%)
setFromHex (450 bytes)	20,700 ops/sec [20,506..22,407] → 20,633 ops/sec [20,325..34,857]	~ overlap (-0.3%)	22,053 ops/sec [21,995..22,129] → 21,501 ops/sec [21,276..21,589]	🔴 -2.5%
toBase64 → fromBase64 (450 bytes)	46,519 ops/sec [42,115..47,559] → 66,034 ops/sec [42,257..68,447]	~ overlap (+41.9%)	48,546 ops/sec [48,180..48,643] → 46,884 ops/sec [46,105..47,363]	🔴 -3.4%
toHex → fromHex (450 bytes)	50,321 ops/sec [50,020..50,959] → 55,406 ops/sec [51,655..83,852]	🟢 +10.1%	58,992 ops/sec [56,182..61,451] → 56,997 ops/sec [56,546..57,797]	~ overlap (-3.4%)

weak-collections.js — Interp: 🟢 3, 12 unch. · avg +4.8% · Bytecode: 🟢 3, 🔴 5, 7 unch. · avg -6.6%

Benchmark	Interpreted (main → PR)	Δ	Bytecode (main → PR)	Δ
constructor from 50 entries	8,968 ops/sec [8,726..10,196] → 9,514 ops/sec [9,387..9,720]	~ overlap (+6.1%)	10,453 ops/sec [10,019..11,266] → 9,630 ops/sec [9,119..10,424]	~ overlap (-7.9%)
set 50 object keys	2,943 ops/sec [2,582..3,053] → 2,889 ops/sec [2,861..3,159]	~ overlap (-1.8%)	3,907 ops/sec [3,861..3,988] → 3,931 ops/sec [3,846..3,950]	~ overlap (+0.6%)
get lookups (50 entries)	43,795 ops/sec [42,398..50,519] → 43,010 ops/sec [42,749..49,175]	~ overlap (-1.8%)	82,878 ops/sec [82,127..83,528] → 81,278 ops/sec [80,617..82,485]	~ overlap (-1.9%)
has checks (50 entries)	57,621 ops/sec [57,037..57,925] → 58,337 ops/sec [54,718..62,334]	~ overlap (+1.2%)	99,808 ops/sec [98,099..100,051] → 101,027 ops/sec [100,798..101,268]	🟢 +1.2%
delete entries	2,683 ops/sec [2,614..2,700] → 2,724 ops/sec [2,710..2,734]	🟢 +1.5%	3,694 ops/sec [3,660..3,732] → 3,793 ops/sec [3,785..3,807]	🟢 +2.7%
non-registered symbol keys	6,498 ops/sec [6,447..6,541] → 6,540 ops/sec [6,501..6,632]	~ overlap (+0.7%)	8,858 ops/sec [8,765..14,563] → 9,034 ops/sec [9,005..9,161]	~ overlap (+2.0%)
getOrInsert	2,814 ops/sec [2,677..2,975] → 2,715 ops/sec [2,697..2,758]	~ overlap (-3.5%)	3,502 ops/sec [3,460..5,804] → 3,623 ops/sec [3,575..3,651]	~ overlap (+3.5%)
getOrInsertComputed	2,462 ops/sec [1,616..2,480] → 1,620 ops/sec [1,595..1,624]	~ overlap (-34.2%)	2,896 ops/sec [2,842..2,930] → 1,841 ops/sec [1,814..1,881]	🔴 -36.4%
forced gc live-key retention	71 ops/sec [62..82] → 61 ops/sec [53..81]	~ overlap (-14.2%)	78 ops/sec [59..81] → 77 ops/sec [75..77]	~ overlap (-0.8%)
constructor from 50 values	11,470 ops/sec [11,262..11,878] → 12,226 ops/sec [11,376..12,553]	~ overlap (+6.6%)	12,336 ops/sec [12,208..12,765] → 11,919 ops/sec [11,726..12,118]	🔴 -3.4%
add 50 object values	3,028 ops/sec [3,005..3,044] → 3,007 ops/sec [2,977..3,015]	~ overlap (-0.7%)	4,171 ops/sec [4,153..6,877] → 4,060 ops/sec [4,048..4,070]	🔴 -2.7%
has checks (50 values)	58,297 ops/sec [58,091..58,547] → 56,505 ops/sec [56,243..90,547]	~ overlap (-3.1%)	168,120 ops/sec [166,546..169,097] → 104,102 ops/sec [100,115..108,011]	🔴 -38.1%
delete values	9,024 ops/sec [8,967..9,082] → 15,045 ops/sec [14,883..15,101]	🟢 +66.7%	17,585 ops/sec [17,191..18,283] → 10,561 ops/sec [10,443..10,755]	🔴 -39.9%
non-registered symbol values	10,928 ops/sec [10,845..11,060] → 10,917 ops/sec [10,833..11,028]	~ overlap (-0.1%)	15,484 ops/sec [15,391..15,498] → 15,608 ops/sec [15,257..15,639]	~ overlap (+0.8%)
forced gc pruning smoke	112 ops/sec [87..140] → 165 ops/sec [157..176]	🟢 +48.1%	135 ops/sec [119..138] → 164 ops/sec [156..185]	🟢 +21.8%

Deterministic profile diff

Deterministic profile diff: no significant changes.

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

[github-actions]

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	19.23s	19.24s
Lex (cumulative)	432.3ms	568.8ms
Parse (cumulative)	337.5ms	432.2ms
Compile (cumulative)	—	891.0ms
Execute (cumulative)	52.1ms	42.91s
Engine Total (cumulative)	821.9ms	44.80s
Lex (avg/worker)	108.1ms	142.2ms
Parse (avg/worker)	84.4ms	108.0ms
Compile (avg/worker)	—	222.7ms
Execute (avg/worker)	13.0ms	10.73s
Engine Total (avg/worker)	205.5ms	11.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	283.78 MiB	281.18 MiB
GC Peak Live	333.28 MiB	306.48 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,572	2,172,697
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.92min	2.69min

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	96.41 MiB	92.22 MiB
GC Allocated During Run	14.98 GiB	9.68 GiB
GC Limit	7.81 GiB	7.81 GiB
GC Collections	3,697	3,604
GC Collected Objects	235,084,732	215,529,694
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.}