Fix cross builds for fcl-base units

[frostney]

Summary

Fix cross-compilation failures when GocciaScript uses fcl-base units such as Base64.

The current cross toolchain only prebuilds a curated subset of FPC packages, so Base64 was unavailable even though it ships with FPC/FCL. This change caches the official fcl-base sources in the cross toolchain and adds that package source directory to the cross compiler unit search path.

Why this change

This is a targeted fix for the current breakage in cross CI.

The broader architectural issue is tracked separately in #170. That issue covers replacing the curated cross-package bootstrap with a proper FPC package installation flow so cross builds stop depending on manual package availability.

Verification

• verified the root cause: Base64 resolves from fcl-base, not from the currently curated cross-package set
• reproduced that compilation fails without fcl-base on the unit path and succeeds once the official fcl-base source path is available
• did not run the full GitHub Actions workflow from the local environment

Summary by CodeRabbit

Release Notes

• Documentation

  • Added details on cross-compilation workflow optimization and FCL package source handling.

• Chores

  • Enhanced CI/CD pipeline to improve cross-compilation support with cached package sources.

[coderabbitai]

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: ba93f486-b539-43b9-909d-3ba5c2288cb5

📥 Commits

Reviewing files that changed from the base of the PR and between f0beafb and 537f401.

📒 Files selected for processing (3)

• .github/workflows/ci.yml
• .github/workflows/toolchain.yml
• docs/build-system.md

---

📝 Walkthrough

Walkthrough

The changes enhance the cross-compilation CI workflow by integrating FCL-base package sources into the cached FPC toolchain and updating compiler invocations to include these sources in the unit search path, enabling resolution of missing FCL units during builds.

Changes

Cohort / File(s)	Summary
Cross-compilation CI workflows .github/workflows/ci.yml, .github/workflows/toolchain.yml	Added FCL_BASE_SRC variable pointing to fcl-base sources, extended cache key with CACHE_VERSION bump, created packages directory in toolchain prefix, copied fcl-base sources into cached toolchain, and updated compiler invocations to include -Fu"$FCL_BASE_SRC" search path.
Build system documentation docs/build-system.md	Documented the cross-compilation workflow's approach of caching reduced FPC toolchain with fcl-base sources to resolve missing FCL units on demand.

Estimated code review effort

🎯 2 (Simple) | ⏱️ ~8 minutes

Possibly related issues

• Replace curated cross-package CI bootstrap with proper FPC package installation #170: Directly addresses the same cross-package missing-FCL issue in CI bootstrapping by caching fcl-base sources and extending compiler unit search paths.

Possibly related PRs

• Add cross-compilation toolchain workflow #93: Modifies the same CI workflows to integrate fcl-base sources into the cached toolchain and extend compiler search paths.

Poem

🐰 A toolchain cache grows oh so wise,
With fcl-base sources tucked inside,
The compiler searches, finds what's right,
No Base64 units lost from sight! 📦✨

🚥 Pre-merge checks | ✅ 3

✅ Passed checks (3 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title accurately summarizes the main change: adding fcl-base unit support to cross builds. It is concise, specific, and directly reflects the primary purpose of the changeset.
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch fix/cross-fcl-base

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

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

[github-actions]

Suite Timing

Suite	Metric	Interpreted	Bytecode
Tests	Total	3563	3563
Tests	Passed	3522 ✅	3563 ✅
Tests	Skipped	41	0
Tests	Execution	170.2ms	180.6ms
Tests	Engine	323.3ms	617.7ms
Benchmarks	Total	263	263
Benchmarks	Duration	7.24min	6.03min

_{Measured on ubuntu-latest x64.}

[github-actions]

Benchmark Results

263 benchmarks

Interpreted: 🟢 109 improved · 🔴 47 regressed · 107 unchanged · avg +0.6%
Bytecode: 🟢 82 improved · 🔴 74 regressed · 107 unchanged · avg +0.4%

arraybuffer.js — Interp: 🟢 4, 🔴 7, 3 unch. · avg -0.7% · Bytecode: 🟢 1, 🔴 8, 5 unch. · avg -1.1%

Benchmark	Interpreted	Δ	Bytecode	Δ
create ArrayBuffer(0)	456,379 ops/sec [445,516..461,714] → 447,305 ops/sec [432,114..463,851]	~ overlap (-2.0%)	492,546 ops/sec [481,317..494,638] → 487,328 ops/sec [484,745..487,584]	~ overlap (-1.1%)
create ArrayBuffer(64)	437,069 ops/sec [436,396..438,043] → 441,651 ops/sec [439,181..444,276]	🟢 +1.0%	463,979 ops/sec [461,273..466,779] → 463,106 ops/sec [445,961..466,551]	~ overlap (-0.2%)
create ArrayBuffer(1024)	342,445 ops/sec [340,506..343,450] → 343,764 ops/sec [343,068..346,736]	~ overlap (+0.4%)	361,176 ops/sec [359,194..362,486] → 356,854 ops/sec [347,703..358,888]	🔴 -1.2%
create ArrayBuffer(8192)	157,661 ops/sec [155,751..158,426] → 151,344 ops/sec [150,468..153,916]	🔴 -4.0%	159,907 ops/sec [158,442..161,029] → 159,636 ops/sec [158,873..160,590]	~ overlap (-0.2%)
slice full buffer (64 bytes)	509,277 ops/sec [508,327..510,591] → 502,144 ops/sec [501,023..503,535]	🔴 -1.4%	604,504 ops/sec [592,818..608,485] → 604,718 ops/sec [602,206..608,895]	~ overlap (+0.0%)
slice half buffer (512 of 1024 bytes)	437,759 ops/sec [433,882..439,515] → 429,025 ops/sec [427,249..430,008]	🔴 -2.0%	526,075 ops/sec [524,530..526,610] → 513,486 ops/sec [511,063..515,585]	🔴 -2.4%
slice with negative indices	419,751 ops/sec [417,946..421,205] → 413,315 ops/sec [411,249..413,982]	🔴 -1.5%	570,895 ops/sec [568,317..572,369] → 554,524 ops/sec [550,073..559,100]	🔴 -2.9%
slice empty range	489,280 ops/sec [487,682..490,273] → 477,274 ops/sec [476,096..479,271]	🔴 -2.5%	598,694 ops/sec [596,864..602,879] → 582,377 ops/sec [580,785..588,092]	🔴 -2.7%
byteLength access	1,373,642 ops/sec [1,371,720..1,375,634] → 1,298,381 ops/sec [1,296,299..1,300,362]	🔴 -5.5%	1,555,535 ops/sec [1,553,609..1,558,384] → 1,536,235 ops/sec [1,523,667..1,538,254]	🔴 -1.2%
Symbol.toStringTag access	1,048,461 ops/sec [1,047,316..1,049,192] → 1,010,879 ops/sec [1,009,370..1,012,202]	🔴 -3.6%	1,059,411 ops/sec [1,046,003..1,061,413] → 1,035,846 ops/sec [1,035,275..1,035,885]	🔴 -2.2%
ArrayBuffer.isView	729,317 ops/sec [725,756..732,729] → 734,066 ops/sec [731,038..738,311]	~ overlap (+0.7%)	852,498 ops/sec [849,484..855,197] → 831,642 ops/sec [829,265..833,155]	🔴 -2.4%
clone ArrayBuffer(64)	409,871 ops/sec [394,918..410,543] → 417,724 ops/sec [416,021..418,438]	🟢 +1.9%	464,462 ops/sec [462,624..466,050] → 465,907 ops/sec [463,272..467,040]	~ overlap (+0.3%)
clone ArrayBuffer(1024)	314,059 ops/sec [309,639..317,253] → 327,438 ops/sec [325,818..327,534]	🟢 +4.3%	352,012 ops/sec [350,994..353,474] → 360,385 ops/sec [357,993..361,570]	🟢 +2.4%
clone ArrayBuffer inside object	255,132 ops/sec [253,579..255,620] → 267,387 ops/sec [267,090..267,808]	🟢 +4.8%	287,655 ops/sec [287,279..288,264] → 283,677 ops/sec [282,710..286,248]	🔴 -1.4%

arrays.js — Interp: 🟢 8, 🔴 2, 9 unch. · avg +0.9% · Bytecode: 🟢 13, 🔴 1, 5 unch. · avg +4.3%

Benchmark	Interpreted	Δ	Bytecode	Δ
Array.from length 100	12,960 ops/sec [12,921..13,185] → 13,211 ops/sec [13,121..13,231]	~ overlap (+1.9%)	14,145 ops/sec [14,103..14,225] → 14,306 ops/sec [14,234..14,392]	🟢 +1.1%
Array.from 10 elements	219,132 ops/sec [218,098..219,924] → 222,510 ops/sec [221,922..223,623]	🟢 +1.5%	239,138 ops/sec [237,869..240,310] → 243,346 ops/sec [242,365..244,287]	🟢 +1.8%
Array.of 10 elements	272,388 ops/sec [268,619..277,964] → 280,866 ops/sec [279,871..281,441]	🟢 +3.1%	298,746 ops/sec [297,280..299,893] → 308,203 ops/sec [306,226..310,970]	🟢 +3.2%
spread into new array	329,869 ops/sec [327,585..330,425] → 323,545 ops/sec [322,183..326,395]	🔴 -1.9%	193,058 ops/sec [191,549..194,557] → 195,383 ops/sec [193,923..195,790]	~ overlap (+1.2%)
map over 50 elements	24,183 ops/sec [23,862..24,469] → 25,126 ops/sec [24,869..25,240]	🟢 +3.9%	26,359 ops/sec [26,318..26,456] → 26,410 ops/sec [26,309..26,443]	~ overlap (+0.2%)
filter over 50 elements	22,663 ops/sec [22,599..22,753] → 22,704 ops/sec [22,610..22,891]	~ overlap (+0.2%)	20,025 ops/sec [19,690..20,185] → 23,091 ops/sec [23,027..23,192]	🟢 +15.3%
reduce sum 50 elements	26,027 ops/sec [25,462..26,113] → 26,268 ops/sec [26,085..26,376]	~ overlap (+0.9%)	19,514 ops/sec [19,385..19,557] → 19,115 ops/sec [19,039..19,162]	🔴 -2.0%
forEach over 50 elements	23,361 ops/sec [23,275..23,418] → 22,898 ops/sec [22,778..23,030]	🔴 -2.0%	26,974 ops/sec [26,919..27,045] → 27,566 ops/sec [27,501..27,711]	🟢 +2.2%
find in 50 elements	33,185 ops/sec [32,962..33,229] → 32,938 ops/sec [32,771..33,168]	~ overlap (-0.7%)	30,112 ops/sec [30,061..30,127] → 30,442 ops/sec [30,348..30,512]	🟢 +1.1%
sort 20 elements	12,139 ops/sec [12,077..12,159] → 12,390 ops/sec [12,346..12,445]	🟢 +2.1%	10,392 ops/sec [10,373..10,408] → 13,410 ops/sec [13,382..13,458]	🟢 +29.0%
flat nested array	114,694 ops/sec [114,040..115,466] → 114,233 ops/sec [113,761..114,524]	~ overlap (-0.4%)	131,537 ops/sec [129,949..132,371] → 130,787 ops/sec [129,596..133,418]	~ overlap (-0.6%)
flatMap	70,762 ops/sec [70,619..70,955] → 71,928 ops/sec [71,153..72,389]	🟢 +1.6%	81,538 ops/sec [80,857..81,825] → 83,388 ops/sec [82,416..84,092]	🟢 +2.3%
map inside map (5x5)	20,235 ops/sec [20,158..20,303] → 20,337 ops/sec [20,239..20,527]	~ overlap (+0.5%)	22,155 ops/sec [21,965..22,193] → 22,459 ops/sec [22,387..22,720]	🟢 +1.4%
filter inside map (5x10)	15,417 ops/sec [15,341..15,577] → 15,591 ops/sec [15,555..15,633]	~ overlap (+1.1%)	14,554 ops/sec [14,469..14,652] → 16,183 ops/sec [16,082..16,293]	🟢 +11.2%
reduce inside map (5x10)	19,034 ops/sec [18,909..19,136] → 19,064 ops/sec [19,000..19,086]	~ overlap (+0.2%)	15,912 ops/sec [15,891..15,960] → 15,952 ops/sec [15,905..16,008]	~ overlap (+0.2%)
forEach inside forEach (5x10)	16,810 ops/sec [16,613..16,870] → 16,687 ops/sec [16,586..16,721]	~ overlap (-0.7%)	16,673 ops/sec [16,622..16,722] → 16,642 ops/sec [16,600..16,690]	~ overlap (-0.2%)
find inside some (10x10)	13,384 ops/sec [13,244..13,418] → 13,534 ops/sec [13,452..13,540]	🟢 +1.1%	12,721 ops/sec [12,697..12,753] → 12,951 ops/sec [12,915..12,981]	🟢 +1.8%
map+filter chain nested (5x20)	5,077 ops/sec [5,040..5,089] → 5,188 ops/sec [5,185..5,190]	🟢 +2.2%	4,949 ops/sec [4,851..5,003] → 5,360 ops/sec [5,342..5,394]	🟢 +8.3%
reduce flatten (10x5)	37,839 ops/sec [37,607..37,955] → 38,562 ops/sec [38,225..38,752]	🟢 +1.9%	17,100 ops/sec [16,900..17,257] → 17,829 ops/sec [17,677..17,882]	🟢 +4.3%

async-await.js — Interp: 🟢 3, 🔴 3 · avg +0.0% · Bytecode: 🔴 2, 4 unch. · avg -0.5%

Benchmark	Interpreted	Δ	Bytecode	Δ
single await	382,290 ops/sec [381,273..383,468] → 376,907 ops/sec [374,484..378,309]	🔴 -1.4%	397,417 ops/sec [393,273..399,598] → 398,898 ops/sec [397,502..399,973]	~ overlap (+0.4%)
multiple awaits	169,467 ops/sec [168,726..170,478] → 168,056 ops/sec [167,589..168,652]	🔴 -0.8%	172,906 ops/sec [171,922..173,265] → 174,701 ops/sec [172,681..175,555]	~ overlap (+1.0%)
await non-Promise value	842,487 ops/sec [835,190..848,094] → 858,130 ops/sec [852,719..861,404]	🟢 +1.9%	1,073,218 ops/sec [1,056,742..1,094,535] → 1,050,057 ops/sec [1,046,662..1,052,700]	🔴 -2.2%
await with try/catch	369,116 ops/sec [367,122..370,242] → 363,642 ops/sec [362,756..365,278]	🔴 -1.5%	396,617 ops/sec [395,317..399,471] → 395,677 ops/sec [391,199..396,787]	~ overlap (-0.2%)
await Promise.all	50,643 ops/sec [50,333..51,041] → 51,222 ops/sec [51,138..51,657]	🟢 +1.1%	51,050 ops/sec [50,840..51,131] → 50,337 ops/sec [50,011..50,582]	🔴 -1.4%
nested async function call	193,154 ops/sec [191,848..193,396] → 194,901 ops/sec [194,104..196,057]	🟢 +0.9%	227,833 ops/sec [227,437..230,212] → 226,200 ops/sec [224,719..229,265]	~ overlap (-0.7%)

classes.js — Interp: 🟢 16, 15 unch. · avg +1.4% · Bytecode: 🟢 7, 🔴 3, 21 unch. · avg +0.2%

Benchmark	Interpreted	Δ	Bytecode	Δ
simple class new	141,367 ops/sec [140,586..141,743] → 141,128 ops/sec [140,866..142,269]	~ overlap (-0.2%)	203,480 ops/sec [202,854..204,412] → 201,794 ops/sec [200,048..203,594]	~ overlap (-0.8%)
class with defaults	111,469 ops/sec [110,159..112,337] → 112,111 ops/sec [111,741..112,335]	~ overlap (+0.6%)	140,725 ops/sec [140,294..142,196] → 139,697 ops/sec [139,486..142,069]	~ overlap (-0.7%)
50 instances via Array.from	5,645 ops/sec [5,637..5,671] → 5,724 ops/sec [5,702..5,772]	🟢 +1.4%	7,919 ops/sec [7,827..7,982] → 7,707 ops/sec [7,656..7,804]	🔴 -2.7%
instance method call	71,331 ops/sec [71,223..71,587] → 71,553 ops/sec [71,474..71,778]	~ overlap (+0.3%)	89,999 ops/sec [89,641..90,079] → 90,620 ops/sec [90,455..91,006]	🟢 +0.7%
static method call	113,776 ops/sec [113,387..114,136] → 115,254 ops/sec [114,763..115,644]	🟢 +1.3%	174,945 ops/sec [174,203..175,592] → 182,216 ops/sec [180,895..182,790]	🟢 +4.2%
single-level inheritance	56,430 ops/sec [56,096..56,897] → 56,756 ops/sec [56,051..57,144]	~ overlap (+0.6%)	72,824 ops/sec [71,066..73,683] → 72,912 ops/sec [72,039..74,131]	~ overlap (+0.1%)
two-level inheritance	48,763 ops/sec [48,617..48,933] → 48,835 ops/sec [48,685..48,925]	~ overlap (+0.1%)	59,116 ops/sec [57,833..60,078] → 60,175 ops/sec [59,283..61,071]	~ overlap (+1.8%)
private field access	71,823 ops/sec [71,497..72,021] → 72,094 ops/sec [71,932..72,202]	~ overlap (+0.4%)	89,831 ops/sec [89,657..90,404] → 88,879 ops/sec [88,107..89,510]	🔴 -1.1%
private methods	80,005 ops/sec [79,246..80,189] → 79,793 ops/sec [79,579..79,845]	~ overlap (-0.3%)	96,938 ops/sec [95,177..98,122] → 97,099 ops/sec [96,661..98,013]	~ overlap (+0.2%)
getter/setter access	76,471 ops/sec [76,158..76,606] → 77,411 ops/sec [77,138..77,553]	🟢 +1.2%	101,542 ops/sec [100,994..103,047] → 102,361 ops/sec [101,853..102,562]	~ overlap (+0.8%)
class decorator (identity)	93,320 ops/sec [92,546..94,424] → 94,829 ops/sec [94,269..95,545]	~ overlap (+1.6%)	101,076 ops/sec [100,233..101,680] → 100,859 ops/sec [100,398..101,722]	~ overlap (-0.2%)
class decorator (wrapping)	55,488 ops/sec [55,107..55,933] → 56,006 ops/sec [55,682..56,282]	~ overlap (+0.9%)	58,539 ops/sec [56,135..61,024] → 56,333 ops/sec [55,158..60,763]	~ overlap (-3.8%)
identity method decorator	66,002 ops/sec [65,718..66,135] → 66,657 ops/sec [66,291..67,180]	🟢 +1.0%	88,691 ops/sec [81,727..94,327] → 84,891 ops/sec [80,646..90,859]	~ overlap (-4.3%)
wrapping method decorator	53,081 ops/sec [52,579..53,495] → 53,598 ops/sec [53,281..53,777]	~ overlap (+1.0%)	59,966 ops/sec [56,965..62,919] → 61,150 ops/sec [58,099..65,251]	~ overlap (+2.0%)
stacked method decorators (x3)	36,350 ops/sec [35,921..36,680] → 36,583 ops/sec [36,344..36,830]	~ overlap (+0.6%)	41,288 ops/sec [40,417..45,032] → 41,564 ops/sec [40,205..44,671]	~ overlap (+0.7%)
identity field decorator	71,178 ops/sec [70,825..71,801] → 73,766 ops/sec [73,344..74,180]	🟢 +3.6%	73,867 ops/sec [71,187..77,057] → 73,561 ops/sec [71,249..76,095]	~ overlap (-0.4%)
field initializer decorator	60,060 ops/sec [59,801..60,221] → 61,194 ops/sec [60,673..61,789]	🟢 +1.9%	62,500 ops/sec [61,290..65,410] → 62,994 ops/sec [60,957..66,550]	~ overlap (+0.8%)
getter decorator (identity)	65,533 ops/sec [65,194..66,111] → 66,400 ops/sec [66,022..66,837]	~ overlap (+1.3%)	72,833 ops/sec [71,677..73,680] → 72,589 ops/sec [70,729..74,127]	~ overlap (-0.3%)
setter decorator (identity)	55,596 ops/sec [54,887..55,959] → 55,712 ops/sec [55,603..55,984]	~ overlap (+0.2%)	62,207 ops/sec [61,906..63,422] → 59,238 ops/sec [58,906..60,478]	🔴 -4.8%
static method decorator	71,222 ops/sec [70,936..71,984] → 72,635 ops/sec [72,377..72,847]	🟢 +2.0%	82,472 ops/sec [80,727..86,488] → 81,150 ops/sec [79,648..84,221]	~ overlap (-1.6%)
static field decorator	82,778 ops/sec [80,374..83,650] → 83,975 ops/sec [83,734..84,595]	🟢 +1.4%	84,569 ops/sec [78,910..88,318] → 87,329 ops/sec [83,021..92,646]	~ overlap (+3.3%)
private method decorator	53,763 ops/sec [53,341..53,938] → 54,574 ops/sec [54,363..54,681]	🟢 +1.5%	73,017 ops/sec [67,326..78,126] → 70,972 ops/sec [67,777..75,664]	~ overlap (-2.8%)
private field decorator	59,761 ops/sec [59,403..60,108] → 60,543 ops/sec [60,408..60,631]	🟢 +1.3%	58,304 ops/sec [57,601..58,678] → 60,906 ops/sec [60,459..62,118]	🟢 +4.5%
plain auto-accessor (no decorator)	105,389 ops/sec [103,721..107,689] → 106,498 ops/sec [105,360..109,070]	~ overlap (+1.1%)	101,316 ops/sec [96,475..109,493] → 96,763 ops/sec [94,552..103,435]	~ overlap (-4.5%)
auto-accessor with decorator	55,702 ops/sec [54,845..56,933] → 56,631 ops/sec [55,624..57,935]	~ overlap (+1.7%)	52,864 ops/sec [51,202..56,442] → 55,131 ops/sec [54,366..61,242]	~ overlap (+4.3%)
decorator writing metadata	44,418 ops/sec [44,052..44,768] → 46,036 ops/sec [45,897..46,356]	🟢 +3.6%	49,625 ops/sec [49,294..54,624] → 48,901 ops/sec [48,474..53,482]	~ overlap (-1.5%)
static getter read	128,578 ops/sec [127,115..129,729] → 133,205 ops/sec [132,785..133,245]	🟢 +3.6%	160,266 ops/sec [159,584..160,593] → 167,690 ops/sec [166,553..168,285]	🟢 +4.6%
static getter/setter pair	99,208 ops/sec [98,979..99,820] → 102,384 ops/sec [101,795..102,589]	🟢 +3.2%	118,554 ops/sec [117,932..118,815] → 119,600 ops/sec [118,987..119,718]	🟢 +0.9%
inherited static getter	78,675 ops/sec [77,972..79,185] → 80,246 ops/sec [80,100..80,624]	🟢 +2.0%	91,150 ops/sec [90,368..91,625] → 96,294 ops/sec [95,028..97,013]	🟢 +5.6%
inherited static setter	84,274 ops/sec [83,440..84,536] → 85,768 ops/sec [85,256..86,388]	🟢 +1.8%	102,511 ops/sec [101,281..105,458] → 100,547 ops/sec [99,459..101,856]	~ overlap (-1.9%)
inherited static getter with this binding	72,298 ops/sec [72,232..72,692] → 73,873 ops/sec [73,788..74,097]	🟢 +2.2%	86,605 ops/sec [85,610..87,743] → 89,198 ops/sec [88,720..89,901]	🟢 +3.0%

closures.js — Interp: 🟢 9, 2 unch. · avg +1.7% · Bytecode: 🟢 6, 🔴 2, 3 unch. · avg +2.5%

Benchmark	Interpreted	Δ	Bytecode	Δ
closure over single variable	134,813 ops/sec [134,295..135,570] → 136,385 ops/sec [135,804..136,547]	🟢 +1.2%	257,043 ops/sec [252,013..260,354] → 279,396 ops/sec [275,866..279,976]	🟢 +8.7%
closure over multiple variables	119,491 ops/sec [119,018..119,959] → 120,328 ops/sec [119,984..120,460]	🟢 +0.7%	184,342 ops/sec [182,265..188,246] → 192,881 ops/sec [190,703..199,345]	🟢 +4.6%
nested closures	127,546 ops/sec [125,236..128,262] → 129,196 ops/sec [128,838..129,454]	🟢 +1.3%	212,415 ops/sec [199,968..221,638] → 227,763 ops/sec [225,165..230,915]	🟢 +7.2%
function as argument	92,455 ops/sec [91,471..93,276] → 94,435 ops/sec [94,097..95,035]	🟢 +2.1%	239,884 ops/sec [238,980..240,456] → 248,275 ops/sec [247,302..250,335]	🟢 +3.5%
function returning function	116,337 ops/sec [115,626..117,692] → 119,251 ops/sec [119,041..119,927]	🟢 +2.5%	266,520 ops/sec [265,168..267,231] → 285,920 ops/sec [284,017..286,851]	🟢 +7.3%
compose two functions	70,134 ops/sec [69,775..70,701] → 72,028 ops/sec [71,777..72,255]	🟢 +2.7%	142,363 ops/sec [141,809..147,170] → 139,175 ops/sec [137,819..144,382]	~ overlap (-2.2%)
fn.call	151,747 ops/sec [151,319..151,970] → 155,328 ops/sec [154,054..155,679]	🟢 +2.4%	225,522 ops/sec [223,919..227,501] → 222,806 ops/sec [222,430..223,882]	🔴 -1.2%
fn.apply	110,080 ops/sec [109,897..110,913] → 113,410 ops/sec [112,679..113,939]	🟢 +3.0%	152,501 ops/sec [151,919..152,589] → 155,219 ops/sec [154,859..155,540]	🟢 +1.8%
fn.bind	142,163 ops/sec [141,197..142,640] → 143,616 ops/sec [143,176..144,028]	🟢 +1.0%	278,686 ops/sec [277,131..283,511] → 278,587 ops/sec [276,296..282,250]	~ overlap (-0.0%)
recursive sum to 50	11,605 ops/sec [11,486..11,641] → 11,728 ops/sec [11,611..11,799]	~ overlap (+1.1%)	23,997 ops/sec [23,706..24,049] → 23,204 ops/sec [23,156..23,269]	🔴 -3.3%
recursive tree traversal	20,123 ops/sec [20,014..20,306] → 20,320 ops/sec [20,189..20,508]	~ overlap (+1.0%)	34,857 ops/sec [34,329..35,297] → 35,431 ops/sec [34,972..36,066]	~ overlap (+1.6%)

collections.js — Interp: 🟢 3, 🔴 7, 2 unch. · avg -2.7% · Bytecode: 🟢 4, 🔴 8 · avg -3.9%

Benchmark	Interpreted	Δ	Bytecode	Δ
add 50 elements	6,973 ops/sec [6,933..7,022] → 6,772 ops/sec [6,691..6,816]	🔴 -2.9%	7,113 ops/sec [7,105..7,143] → 6,905 ops/sec [6,894..6,936]	🔴 -2.9%
has lookup (50 elements)	88,518 ops/sec [88,309..88,935] → 84,110 ops/sec [83,933..84,253]	🔴 -5.0%	99,156 ops/sec [98,881..99,233] → 92,467 ops/sec [91,963..92,831]	🔴 -6.7%
delete elements	47,449 ops/sec [47,358..47,462] → 45,385 ops/sec [45,293..45,593]	🔴 -4.3%	49,019 ops/sec [48,789..49,190] → 46,349 ops/sec [46,121..46,595]	🔴 -5.4%
forEach iteration	15,806 ops/sec [15,729..15,819] → 15,864 ops/sec [15,701..15,991]	~ overlap (+0.4%)	14,871 ops/sec [14,803..14,913] → 15,274 ops/sec [15,257..15,368]	🟢 +2.7%
spread to array	28,755 ops/sec [28,559..28,905] → 29,437 ops/sec [29,204..29,690]	🟢 +2.4%	211,379 ops/sec [208,275..217,326] → 219,533 ops/sec [217,986..220,403]	🟢 +3.9%
deduplicate array	38,206 ops/sec [38,068..38,332] → 38,874 ops/sec [38,770..38,996]	🟢 +1.7%	70,646 ops/sec [70,340..71,317] → 69,799 ops/sec [69,441..69,976]	🔴 -1.2%
set 50 entries	5,183 ops/sec [5,166..5,202] → 4,986 ops/sec [4,924..5,010]	🔴 -3.8%	5,574 ops/sec [5,545..5,601] → 5,085 ops/sec [5,078..5,120]	🔴 -8.8%
get lookup (50 entries)	84,727 ops/sec [84,466..85,243] → 75,345 ops/sec [74,790..75,481]	🔴 -11.1%	91,371 ops/sec [91,164..91,521] → 80,540 ops/sec [80,338..80,682]	🔴 -11.9%
has check	126,115 ops/sec [125,484..126,590] → 117,566 ops/sec [113,963..118,099]	🔴 -6.8%	140,600 ops/sec [140,344..140,903] → 124,184 ops/sec [123,750..124,447]	🔴 -11.7%
delete entries	44,921 ops/sec [44,717..45,130] → 41,312 ops/sec [40,913..41,442]	🔴 -8.0%	46,340 ops/sec [46,294..46,373] → 41,423 ops/sec [41,329..41,486]	🔴 -10.6%
forEach iteration	15,643 ops/sec [15,532..15,714] → 15,934 ops/sec [15,702..16,007]	~ overlap (+1.9%)	15,150 ops/sec [15,111..15,163] → 15,357 ops/sec [15,315..15,375]	🟢 +1.4%
keys/values/entries	7,863 ops/sec [7,793..7,919] → 8,133 ops/sec [8,068..8,199]	🟢 +3.4%	26,023 ops/sec [25,666..26,666] → 27,187 ops/sec [26,772..27,276]	🟢 +4.5%

destructuring.js — Interp: 🟢 11, 🔴 3, 8 unch. · avg +1.3% · Bytecode: 🟢 7, 🔴 1, 14 unch. · avg +0.6%

Benchmark	Interpreted	Δ	Bytecode	Δ
simple array destructuring	379,956 ops/sec [378,570..381,835] → 386,534 ops/sec [385,887..389,873]	🟢 +1.7%	262,827 ops/sec [258,199..266,907] → 267,571 ops/sec [264,593..270,096]	~ overlap (+1.8%)
with rest element	245,454 ops/sec [244,833..245,568] → 249,006 ops/sec [246,914..250,532]	🟢 +1.4%	207,069 ops/sec [204,752..207,890] → 209,127 ops/sec [208,110..210,264]	🟢 +1.0%
with defaults	399,428 ops/sec [395,383..399,895] → 385,145 ops/sec [382,934..386,058]	🔴 -3.6%	298,031 ops/sec [290,849..303,564] → 307,792 ops/sec [303,192..311,323]	~ overlap (+3.3%)
skip elements	398,124 ops/sec [396,328..402,392] → 410,377 ops/sec [407,150..413,445]	🟢 +3.1%	285,786 ops/sec [279,643..289,176] → 292,872 ops/sec [290,678..294,371]	🟢 +2.5%
nested array destructuring	169,596 ops/sec [167,990..171,614] → 170,289 ops/sec [168,609..171,030]	~ overlap (+0.4%)	86,461 ops/sec [84,861..87,624] → 89,426 ops/sec [88,311..90,587]	🟢 +3.4%
swap variables	505,151 ops/sec [499,912..508,004] → 513,797 ops/sec [511,874..515,345]	🟢 +1.7%	337,424 ops/sec [324,363..340,566] → 335,715 ops/sec [332,539..338,195]	~ overlap (-0.5%)
simple object destructuring	304,285 ops/sec [304,091..304,723] → 315,660 ops/sec [314,073..316,949]	🟢 +3.7%	417,295 ops/sec [413,403..425,259] → 403,307 ops/sec [399,717..407,265]	🔴 -3.4%
with defaults	343,867 ops/sec [342,858..346,603] → 351,457 ops/sec [349,868..352,892]	🟢 +2.2%	540,732 ops/sec [535,823..547,803] → 545,958 ops/sec [543,761..560,519]	~ overlap (+1.0%)
with renaming	327,758 ops/sec [326,057..331,019] → 331,736 ops/sec [329,251..336,358]	~ overlap (+1.2%)	442,359 ops/sec [438,645..450,039] → 434,865 ops/sec [432,691..442,347]	~ overlap (-1.7%)
nested object destructuring	148,851 ops/sec [148,600..149,288] → 155,081 ops/sec [154,762..156,235]	🟢 +4.2%	198,137 ops/sec [192,995..198,666] → 199,792 ops/sec [197,987..201,720]	~ overlap (+0.8%)
rest properties	183,569 ops/sec [182,406..185,452] → 188,903 ops/sec [187,579..190,531]	🟢 +2.9%	183,399 ops/sec [178,964..183,953] → 181,666 ops/sec [181,271..183,788]	~ overlap (-0.9%)
object parameter	92,087 ops/sec [91,380..94,377] → 97,173 ops/sec [96,453..97,662]	🟢 +5.5%	147,074 ops/sec [146,951..147,161] → 150,384 ops/sec [148,451..151,104]	🟢 +2.3%
array parameter	118,669 ops/sec [117,913..119,381] → 120,949 ops/sec [120,308..121,328]	🟢 +1.9%	104,998 ops/sec [104,212..105,481] → 108,047 ops/sec [106,258..110,539]	🟢 +2.9%
mixed destructuring in map	33,051 ops/sec [32,920..33,269] → 32,668 ops/sec [32,439..32,797]	🔴 -1.2%	34,721 ops/sec [34,550..34,878] → 34,287 ops/sec [34,114..34,729]	~ overlap (-1.2%)
forEach with array destructuring	63,120 ops/sec [62,725..63,238] → 62,904 ops/sec [62,862..63,140]	~ overlap (-0.3%)	41,050 ops/sec [40,033..41,416] → 41,439 ops/sec [41,097..41,614]	~ overlap (+0.9%)
map with array destructuring	62,473 ops/sec [61,929..63,116] → 63,092 ops/sec [62,983..63,496]	~ overlap (+1.0%)	41,731 ops/sec [40,784..41,955] → 42,607 ops/sec [42,115..42,777]	🟢 +2.1%
filter with array destructuring	65,132 ops/sec [64,735..65,434] → 65,664 ops/sec [65,159..66,046]	~ overlap (+0.8%)	46,174 ops/sec [45,685..46,628] → 47,242 ops/sec [46,906..47,374]	🟢 +2.3%
reduce with array destructuring	70,791 ops/sec [69,568..71,666] → 71,925 ops/sec [71,255..72,510]	~ overlap (+1.6%)	46,191 ops/sec [45,301..46,944] → 46,447 ops/sec [46,111..46,991]	~ overlap (+0.6%)
map with object destructuring	73,170 ops/sec [72,794..73,484] → 73,209 ops/sec [72,677..73,657]	~ overlap (+0.1%)	87,132 ops/sec [86,566..87,466] → 86,754 ops/sec [85,448..87,009]	~ overlap (-0.4%)
map with nested destructuring	60,897 ops/sec [60,705..61,526] → 60,477 ops/sec [59,996..60,798]	~ overlap (-0.7%)	83,362 ops/sec [82,644..84,367] → 83,101 ops/sec [82,931..83,741]	~ overlap (-0.3%)
map with rest in destructuring	40,683 ops/sec [40,461..40,726] → 42,110 ops/sec [41,406..42,459]	🟢 +3.5%	23,845 ops/sec [23,574..23,981] → 23,362 ops/sec [23,195..23,617]	~ overlap (-2.0%)
map with defaults in destructuring	56,490 ops/sec [56,185..56,808] → 55,498 ops/sec [55,025..55,716]	🔴 -1.8%	63,831 ops/sec [62,991..64,637] → 63,265 ops/sec [62,481..63,650]	~ overlap (-0.9%)

fibonacci.js — Interp: 🟢 6, 2 unch. · avg +2.0% · Bytecode: 🟢 3, 🔴 4, 1 unch. · avg +0.3%

Benchmark	Interpreted	Δ	Bytecode	Δ
recursive fib(15)	310 ops/sec [306..314] → 318 ops/sec [315..322]	🟢 +2.9%	833 ops/sec [832..834] → 812 ops/sec [810..812]	🔴 -2.5%
recursive fib(20)	28 ops/sec [28..28] → 28 ops/sec [28..28]	~ overlap (+0.3%)	75 ops/sec [75..75] → 73 ops/sec [73..73]	🔴 -1.9%
recursive fib(15) typed	312 ops/sec [308..319] → 319 ops/sec [318..321]	~ overlap (+2.3%)	886 ops/sec [882..889] → 855 ops/sec [854..856]	🔴 -3.4%
recursive fib(20) typed	28 ops/sec [28..28] → 28 ops/sec [28..28]	🟢 +0.5%	80 ops/sec [79..80] → 77 ops/sec [76..77]	🔴 -4.0%
iterative fib(20) via reduce	12,050 ops/sec [11,989..12,191] → 12,281 ops/sec [12,253..12,364]	🟢 +1.9%	17,942 ops/sec [17,681..18,066] → 18,182 ops/sec [18,073..18,251]	🟢 +1.3%
iterator fib(20)	9,419 ops/sec [9,351..9,516] → 9,684 ops/sec [9,559..9,728]	🟢 +2.8%	17,355 ops/sec [17,310..17,387] → 17,776 ops/sec [17,689..17,911]	🟢 +2.4%
iterator fib(20) via Iterator.from + take	15,246 ops/sec [15,060..15,352] → 15,693 ops/sec [15,601..15,854]	🟢 +2.9%	20,377 ops/sec [20,170..20,781] → 21,066 ops/sec [20,658..21,195]	~ overlap (+3.4%)
iterator fib(20) last value via reduce	11,333 ops/sec [11,252..11,410] → 11,634 ops/sec [11,540..11,705]	🟢 +2.7%	13,673 ops/sec [13,523..13,974] → 14,613 ops/sec [14,539..14,653]	🟢 +6.9%

for-of.js — Interp: 🟢 7 · avg +3.9% · Bytecode: 🟢 3, 4 unch. · avg +2.2%

Benchmark	Interpreted	Δ	Bytecode	Δ
for...of with 10-element array	44,679 ops/sec [44,524..45,085] → 46,573 ops/sec [46,213..46,643]	🟢 +4.2%	162,485 ops/sec [161,682..165,667] → 164,674 ops/sec [163,079..165,087]	~ overlap (+1.3%)
for...of with 100-element array	5,145 ops/sec [5,111..5,178] → 5,314 ops/sec [5,269..5,337]	🟢 +3.3%	17,440 ops/sec [17,241..17,517] → 17,823 ops/sec [17,654..17,972]	🟢 +2.2%
for...of with string (10 chars)	33,482 ops/sec [33,294..33,741] → 34,302 ops/sec [34,208..34,572]	🟢 +2.5%	84,383 ops/sec [83,522..85,717] → 84,114 ops/sec [82,873..84,807]	~ overlap (-0.3%)
for...of with Set (10 elements)	44,850 ops/sec [44,388..45,098] → 46,814 ops/sec [46,447..47,011]	🟢 +4.4%	151,256 ops/sec [150,330..152,424] → 153,466 ops/sec [151,655..157,109]	~ overlap (+1.5%)
for...of with Map entries (10 entries)	28,784 ops/sec [28,501..29,148] → 29,827 ops/sec [29,637..29,984]	🟢 +3.6%	27,506 ops/sec [27,335..27,823] → 28,118 ops/sec [27,514..28,251]	~ overlap (+2.2%)
for...of with destructuring	38,264 ops/sec [38,191..38,573] → 39,726 ops/sec [39,234..39,897]	🟢 +3.8%	35,188 ops/sec [33,855..35,439] → 36,726 ops/sec [36,328..36,854]	🟢 +4.4%
for-await-of with sync array	42,710 ops/sec [42,513..42,803] → 44,973 ops/sec [44,715..45,113]	🟢 +5.3%	124,653 ops/sec [123,127..126,235] → 129,393 ops/sec [127,972..130,138]	🟢 +3.8%

helpers/bench-module.js — Interp: 0 · Bytecode: 0

Benchmark	Interpreted	Δ	Bytecode	Δ

iterators.js — Interp: 🟢 19, 1 unch. · avg +3.4% · Bytecode: 🟢 10, 🔴 1, 9 unch. · avg +2.0%

Benchmark	Interpreted	Δ	Bytecode	Δ
Iterator.from({next}).toArray() — 20 elements	15,178 ops/sec [14,984..15,326] → 15,751 ops/sec [15,383..15,830]	🟢 +3.8%	19,271 ops/sec [19,232..19,449] → 20,472 ops/sec [20,421..20,497]	🟢 +6.2%
Iterator.from({next}).toArray() — 50 elements	6,593 ops/sec [6,518..6,670] → 6,880 ops/sec [6,814..6,904]	🟢 +4.3%	9,006 ops/sec [8,982..9,078] → 9,050 ops/sec [8,867..9,067]	~ overlap (+0.5%)
spread pre-wrapped iterator — 20 elements	11,316 ops/sec [11,178..11,379] → 11,878 ops/sec [11,853..11,918]	🟢 +5.0%	19,372 ops/sec [18,976..19,769] → 20,406 ops/sec [20,220..20,557]	🟢 +5.3%
Iterator.from({next}).forEach — 50 elements	4,577 ops/sec [4,529..4,600] → 4,728 ops/sec [4,693..4,758]	🟢 +3.3%	5,437 ops/sec [5,411..5,474] → 5,630 ops/sec [5,585..5,662]	🟢 +3.5%
Iterator.from({next}).reduce — 50 elements	4,548 ops/sec [4,532..4,557] → 4,749 ops/sec [4,735..4,763]	🟢 +4.4%	5,214 ops/sec [5,155..5,256] → 5,262 ops/sec [5,246..5,307]	~ overlap (+0.9%)
wrap array iterator	159,203 ops/sec [157,915..160,452] → 165,156 ops/sec [162,463..166,552]	🟢 +3.7%	184,069 ops/sec [182,615..185,046] → 179,065 ops/sec [178,138..180,656]	🔴 -2.7%
wrap plain {next()} object	10,602 ops/sec [10,495..10,715] → 11,045 ops/sec [10,946..11,073]	🟢 +4.2%	14,156 ops/sec [14,060..14,344] → 14,303 ops/sec [14,238..14,416]	~ overlap (+1.0%)
map + toArray (50 elements)	4,595 ops/sec [4,546..4,662] → 4,747 ops/sec [4,710..4,763]	🟢 +3.3%	5,849 ops/sec [5,833..5,863] → 6,030 ops/sec [5,930..6,046]	🟢 +3.1%
filter + toArray (50 elements)	4,464 ops/sec [4,404..4,491] → 4,633 ops/sec [4,603..4,650]	🟢 +3.8%	5,485 ops/sec [5,473..5,494] → 5,700 ops/sec [5,654..5,723]	🟢 +3.9%
take(10) + toArray (50 element source)	27,937 ops/sec [27,846..28,223] → 28,975 ops/sec [28,878..29,062]	🟢 +3.7%	35,242 ops/sec [34,959..36,111] → 36,389 ops/sec [36,307..36,541]	🟢 +3.3%
drop(40) + toArray (50 element source)	6,676 ops/sec [6,628..6,732] → 6,843 ops/sec [6,797..6,890]	🟢 +2.5%	8,967 ops/sec [8,852..9,032] → 9,168 ops/sec [9,148..9,251]	🟢 +2.2%
chained map + filter + take (100 element source)	8,154 ops/sec [8,110..8,196] → 8,404 ops/sec [8,353..8,476]	🟢 +3.1%	9,867 ops/sec [9,741..9,917] → 10,268 ops/sec [10,215..10,366]	🟢 +4.1%
some + every (50 elements)	2,636 ops/sec [2,623..2,650] → 2,720 ops/sec [2,689..2,742]	🟢 +3.2%	3,540 ops/sec [3,513..3,569] → 3,581 ops/sec [3,536..3,586]	~ overlap (+1.1%)
find (50 elements)	5,682 ops/sec [5,592..5,702] → 5,953 ops/sec [5,918..5,983]	🟢 +4.8%	7,002 ops/sec [6,981..7,060] → 7,130 ops/sec [7,068..7,193]	🟢 +1.8%
array.values().map().filter().toArray()	7,917 ops/sec [7,711..7,938] → 8,156 ops/sec [8,059..8,169]	🟢 +3.0%	9,563 ops/sec [9,513..9,602] → 9,578 ops/sec [9,451..9,740]	~ overlap (+0.2%)
array.values().take(5).toArray()	211,050 ops/sec [209,255..213,264] → 217,496 ops/sec [216,739..218,798]	🟢 +3.1%	225,472 ops/sec [224,098..227,688] → 226,898 ops/sec [223,611..230,306]	~ overlap (+0.6%)
array.values().drop(45).toArray()	193,761 ops/sec [191,202..195,214] → 200,521 ops/sec [198,593..201,436]	🟢 +3.5%	213,097 ops/sec [211,892..213,604] → 211,837 ops/sec [210,683..214,166]	~ overlap (-0.6%)
map.entries() chained helpers	10,083 ops/sec [9,948..10,147] → 10,253 ops/sec [10,207..10,324]	🟢 +1.7%	5,944 ops/sec [5,904..5,986] → 5,968 ops/sec [5,934..6,007]	~ overlap (+0.4%)
set.values() chained helpers	16,737 ops/sec [16,444..16,821] → 17,193 ops/sec [17,162..17,249]	🟢 +2.7%	18,328 ops/sec [18,010..18,455] → 19,419 ops/sec [19,253..19,500]	🟢 +6.0%
string iterator map + toArray	13,410 ops/sec [13,305..13,614] → 13,636 ops/sec [13,548..13,754]	~ overlap (+1.7%)	14,392 ops/sec [14,166..14,576] → 14,202 ops/sec [14,056..14,287]	~ overlap (-1.3%)

json.js — Interp: 🔴 6, 14 unch. · avg -1.1% · Bytecode: 🔴 9, 11 unch. · avg -2.0%

Benchmark	Interpreted	Δ	Bytecode	Δ
parse simple object	173,203 ops/sec [171,501..175,443] → 176,553 ops/sec [174,309..178,327]	~ overlap (+1.9%)	173,985 ops/sec [170,638..175,694] → 172,448 ops/sec [170,997..173,590]	~ overlap (-0.9%)
parse nested object	105,143 ops/sec [103,246..106,718] → 107,028 ops/sec [106,130..107,425]	~ overlap (+1.8%)	108,544 ops/sec [107,805..109,437] → 108,418 ops/sec [106,403..109,446]	~ overlap (-0.1%)
parse array of objects	62,413 ops/sec [62,159..63,014] → 62,812 ops/sec [62,001..62,972]	~ overlap (+0.6%)	61,247 ops/sec [60,256..62,232] → 62,226 ops/sec [61,272..62,994]	~ overlap (+1.6%)
parse large flat object	68,192 ops/sec [67,936..69,029] → 68,167 ops/sec [66,703..68,638]	~ overlap (-0.0%)	68,908 ops/sec [68,374..70,345] → 69,527 ops/sec [68,895..70,040]	~ overlap (+0.9%)
parse mixed types	79,198 ops/sec [78,834..80,427] → 78,875 ops/sec [78,500..79,506]	~ overlap (-0.4%)	79,115 ops/sec [78,171..80,476] → 77,521 ops/sec [76,845..78,701]	~ overlap (-2.0%)
stringify simple object	170,652 ops/sec [169,194..171,176] → 170,622 ops/sec [169,072..171,385]	~ overlap (-0.0%)	181,434 ops/sec [180,752..183,652] → 175,863 ops/sec [175,316..176,601]	🔴 -3.1%
stringify nested object	98,613 ops/sec [97,361..99,888] → 97,276 ops/sec [97,078..97,995]	~ overlap (-1.4%)	101,035 ops/sec [100,334..102,699] → 99,039 ops/sec [98,544..99,554]	🔴 -2.0%
stringify array of objects	47,550 ops/sec [47,087..47,743] → 44,794 ops/sec [44,709..44,806]	🔴 -5.8%	47,518 ops/sec [47,401..47,766] → 44,753 ops/sec [44,498..44,962]	🔴 -5.8%
stringify mixed types	73,885 ops/sec [73,261..74,899] → 71,573 ops/sec [71,252..72,032]	🔴 -3.1%	73,698 ops/sec [72,408..73,885] → 71,527 ops/sec [71,083..72,192]	🔴 -2.9%
reviver doubles numbers	48,528 ops/sec [47,635..48,777] → 48,633 ops/sec [47,773..49,037]	~ overlap (+0.2%)	53,015 ops/sec [52,329..53,866] → 52,246 ops/sec [51,113..54,343]	~ overlap (-1.4%)
reviver filters properties	40,823 ops/sec [40,710..41,136] → 40,765 ops/sec [40,632..41,009]	~ overlap (-0.1%)	42,971 ops/sec [42,475..43,072] → 42,007 ops/sec [41,854..42,203]	🔴 -2.2%
reviver on nested object	52,250 ops/sec [52,073..52,339] → 52,271 ops/sec [52,182..52,525]	~ overlap (+0.0%)	54,255 ops/sec [53,924..54,357] → 53,409 ops/sec [53,052..54,067]	~ overlap (-1.6%)
reviver on array	32,419 ops/sec [32,345..32,681] → 32,019 ops/sec [31,437..32,556]	~ overlap (-1.2%)	33,257 ops/sec [32,872..33,439] → 32,092 ops/sec [31,473..32,592]	🔴 -3.5%
replacer function doubles numbers	42,916 ops/sec [42,750..42,958] → 42,525 ops/sec [42,414..43,130]	~ overlap (-0.9%)	46,063 ops/sec [45,896..46,561] → 45,367 ops/sec [45,082..46,379]	~ overlap (-1.5%)
replacer function excludes properties	56,802 ops/sec [56,340..57,420] → 55,818 ops/sec [55,128..56,235]	🔴 -1.7%	57,952 ops/sec [57,575..58,106] → 56,710 ops/sec [56,423..56,949]	🔴 -2.1%
array replacer (allowlist)	100,122 ops/sec [94,848..100,772] → 100,008 ops/sec [99,521..100,707]	~ overlap (-0.1%)	103,028 ops/sec [102,769..103,528] → 101,713 ops/sec [100,816..103,374]	~ overlap (-1.3%)
stringify with 2-space indent	81,498 ops/sec [80,524..81,601] → 79,579 ops/sec [79,301..79,793]	🔴 -2.4%	84,728 ops/sec [84,206..85,091] → 82,378 ops/sec [81,820..82,660]	🔴 -2.8%
stringify with tab indent	81,935 ops/sec [81,254..82,576] → 81,247 ops/sec [80,312..81,668]	~ overlap (-0.8%)	83,524 ops/sec [83,061..83,867] → 82,136 ops/sec [81,729..83,231]	~ overlap (-1.7%)
parse then stringify	50,902 ops/sec [50,572..51,351] → 48,882 ops/sec [48,707..48,951]	🔴 -4.0%	53,006 ops/sec [52,354..53,181] → 51,727 ops/sec [51,132..52,493]	~ overlap (-2.4%)
stringify then parse	31,311 ops/sec [31,109..31,403] → 30,083 ops/sec [29,910..30,262]	🔴 -3.9%	32,876 ops/sec [32,534..33,276] → 31,300 ops/sec [30,865..31,434]	🔴 -4.8%

jsx.jsx — Interp: 🟢 1, 🔴 4, 16 unch. · avg -0.2% · Bytecode: 🟢 13, 🔴 1, 7 unch. · avg +2.7%

Benchmark	Interpreted	Δ	Bytecode	Δ
simple element	213,416 ops/sec [212,104..214,316] → 212,111 ops/sec [211,250..213,889]	~ overlap (-0.6%)	314,531 ops/sec [311,947..316,016] → 319,810 ops/sec [316,186..325,064]	🟢 +1.7%
self-closing element	223,171 ops/sec [221,637..224,486] → 219,954 ops/sec [217,918..220,349]	🔴 -1.4%	351,456 ops/sec [349,252..357,574] → 355,731 ops/sec [354,418..358,540]	~ overlap (+1.2%)
element with string attribute	177,557 ops/sec [176,496..178,687] → 179,450 ops/sec [178,648..180,170]	~ overlap (+1.1%)	258,484 ops/sec [255,959..261,597] → 274,537 ops/sec [270,233..280,261]	🟢 +6.2%
element with multiple attributes	157,241 ops/sec [155,510..158,664] → 158,380 ops/sec [157,029..160,116]	~ overlap (+0.7%)	206,395 ops/sec [204,623..208,459] → 205,831 ops/sec [204,494..206,312]	~ overlap (-0.3%)
element with expression attribute	167,223 ops/sec [165,628..168,847] → 168,030 ops/sec [159,443..168,312]	~ overlap (+0.5%)	248,193 ops/sec [245,322..249,081] → 261,530 ops/sec [260,053..265,452]	🟢 +5.4%
text child	215,109 ops/sec [214,111..215,788] → 212,278 ops/sec [211,735..213,208]	🔴 -1.3%	323,757 ops/sec [318,393..327,971] → 324,111 ops/sec [322,682..325,983]	~ overlap (+0.1%)
expression child	208,453 ops/sec [207,692..209,708] → 207,723 ops/sec [204,950..210,090]	~ overlap (-0.4%)	314,569 ops/sec [313,525..314,776] → 331,855 ops/sec [331,258..336,611]	🟢 +5.5%
mixed text and expression	199,535 ops/sec [197,955..199,593] → 196,391 ops/sec [194,649..198,267]	~ overlap (-1.6%)	292,693 ops/sec [291,671..293,403] → 289,234 ops/sec [288,553..290,129]	🔴 -1.2%
nested elements (3 levels)	82,060 ops/sec [81,712..82,505] → 80,862 ops/sec [80,329..81,323]	🔴 -1.5%	119,140 ops/sec [118,166..119,473] → 128,818 ops/sec [128,530..130,599]	🟢 +8.1%
sibling children	59,668 ops/sec [59,388..60,078] → 60,574 ops/sec [60,326..60,918]	🟢 +1.5%	87,985 ops/sec [87,177..88,424] → 89,182 ops/sec [88,504..91,721]	🟢 +1.4%
component element	150,572 ops/sec [147,415..152,511] → 150,673 ops/sec [149,910..152,464]	~ overlap (+0.1%)	228,273 ops/sec [226,640..228,480] → 232,724 ops/sec [230,668..234,012]	🟢 +1.9%
component with children	92,516 ops/sec [92,187..92,555] → 92,457 ops/sec [91,614..93,009]	~ overlap (-0.1%)	136,295 ops/sec [135,438..137,979] → 137,520 ops/sec [134,245..139,406]	~ overlap (+0.9%)
dotted component	126,241 ops/sec [125,513..126,931] → 125,913 ops/sec [125,515..126,688]	~ overlap (-0.3%)	174,526 ops/sec [173,098..175,030] → 180,892 ops/sec [179,838..181,130]	🟢 +3.6%
empty fragment	222,551 ops/sec [219,703..223,374] → 224,521 ops/sec [222,115..226,906]	~ overlap (+0.9%)	372,086 ops/sec [369,967..374,190] → 370,801 ops/sec [370,167..376,483]	~ overlap (-0.3%)
fragment with children	59,743 ops/sec [58,960..59,953] → 59,719 ops/sec [59,577..59,810]	~ overlap (-0.0%)	88,569 ops/sec [88,091..89,338] → 93,660 ops/sec [93,436..94,592]	🟢 +5.7%
spread attributes	111,299 ops/sec [110,500..111,871] → 108,481 ops/sec [107,779..108,927]	🔴 -2.5%	133,810 ops/sec [131,062..140,879] → 133,619 ops/sec [132,906..133,856]	~ overlap (-0.1%)
spread with overrides	96,193 ops/sec [95,940..96,540] → 96,765 ops/sec [96,183..97,620]	~ overlap (+0.6%)	117,489 ops/sec [116,924..118,272] → 120,214 ops/sec [119,857..120,892]	🟢 +2.3%
shorthand props	161,546 ops/sec [159,601..162,507] → 160,679 ops/sec [158,511..161,147]	~ overlap (-0.5%)	236,305 ops/sec [234,619..238,571] → 238,475 ops/sec [237,125..241,703]	~ overlap (+0.9%)
nav bar structure	27,782 ops/sec [27,674..28,166] → 27,715 ops/sec [27,570..27,896]	~ overlap (-0.2%)	39,622 ops/sec [39,253..39,872] → 42,264 ops/sec [42,123..42,400]	🟢 +6.7%
card component tree	32,119 ops/sec [31,548..32,483] → 32,239 ops/sec [31,835..32,379]	~ overlap (+0.4%)	44,259 ops/sec [43,757..44,598] → 45,523 ops/sec [45,296..46,152]	🟢 +2.9%
10 list items via Array.from	14,634 ops/sec [14,487..14,801] → 14,664 ops/sec [14,589..14,785]	~ overlap (+0.2%)	19,170 ops/sec [18,987..19,247] → 19,935 ops/sec [19,863..20,092]	🟢 +4.0%

modules.js — Interp: 🔴 9 · avg -5.6% · Bytecode: 🟢 1, 🔴 7, 1 unch. · avg -2.5%

Benchmark	Interpreted	Δ	Bytecode	Δ
call imported function	464,341 ops/sec [457,913..466,795] → 450,037 ops/sec [446,321..452,440]	🔴 -3.1%	639,387 ops/sec [637,574..642,966] → 627,710 ops/sec [614,206..635,002]	🔴 -1.8%
call two imported functions	262,853 ops/sec [260,016..264,588] → 251,492 ops/sec [248,953..252,567]	🔴 -4.3%	352,837 ops/sec [351,862..353,270] → 347,988 ops/sec [345,097..359,066]	~ overlap (-1.4%)
read imported constant	1,686,728 ops/sec [1,672,919..1,691,658] → 1,584,404 ops/sec [1,573,975..1,599,258]	🔴 -6.1%	3,596,244 ops/sec [3,588,558..3,610,331] → 3,517,709 ops/sec [3,514,943..3,529,050]	🔴 -2.2%
read imported string	1,658,997 ops/sec [1,646,564..1,668,632] → 1,580,210 ops/sec [1,576,841..1,580,823]	🔴 -4.7%	3,604,314 ops/sec [3,599,675..3,624,786] → 3,519,532 ops/sec [3,500,734..3,527,220]	🔴 -2.4%
read JSON string property	1,697,491 ops/sec [1,688,523..1,704,477] → 1,597,846 ops/sec [1,591,363..1,603,252]	🔴 -5.9%	3,631,173 ops/sec [3,579,638..3,704,588] → 3,492,729 ops/sec [3,486,465..3,497,747]	🔴 -3.8%
read JSON number property	1,651,449 ops/sec [1,649,578..1,653,025] → 1,567,214 ops/sec [1,564,084..1,577,565]	🔴 -5.1%	3,680,398 ops/sec [3,676,829..3,680,904] → 3,532,760 ops/sec [3,524,921..3,536,239]	🔴 -4.0%
read JSON boolean property	1,678,057 ops/sec [1,657,149..1,688,715] → 1,588,054 ops/sec [1,581,322..1,598,548]	🔴 -5.4%	3,682,785 ops/sec [3,670,984..3,683,943] → 3,528,023 ops/sec [3,511,434..3,534,052]	🔴 -4.2%
read JSON array property	1,675,892 ops/sec [1,669,569..1,683,537] → 1,596,904 ops/sec [1,585,444..1,600,119]	🔴 -4.7%	3,678,636 ops/sec [3,664,022..3,684,347] → 3,526,920 ops/sec [3,517,186..3,533,987]	🔴 -4.1%
read multiple JSON properties	983,757 ops/sec [972,532..995,462] → 878,168 ops/sec [875,185..886,482]	🔴 -10.7%	3,148,629 ops/sec [3,137,889..3,151,326] → 3,192,983 ops/sec [3,185,777..3,201,065]	🟢 +1.4%

numbers.js — Interp: 🟢 3, 🔴 3, 5 unch. · avg +0.2% · Bytecode: 🟢 2, 🔴 5, 4 unch. · avg +1.1%

Benchmark	Interpreted	Δ	Bytecode	Δ
integer arithmetic	519,135 ops/sec [514,539..520,848] → 507,351 ops/sec [503,369..509,869]	🔴 -2.3%	1,103,036 ops/sec [1,099,201..1,104,851] → 1,456,472 ops/sec [1,381,949..1,458,111]	🟢 +32.0%
floating point arithmetic	609,732 ops/sec [604,633..615,413] → 582,215 ops/sec [573,420..583,365]	🔴 -4.5%	974,051 ops/sec [947,754..987,044] → 936,619 ops/sec [931,458..940,593]	🔴 -3.8%
number coercion	180,286 ops/sec [178,127..181,232] → 183,369 ops/sec [178,421..184,342]	~ overlap (+1.7%)	226,822 ops/sec [224,933..228,289] → 215,276 ops/sec [214,034..217,434]	🔴 -5.1%
toFixed	102,940 ops/sec [102,780..103,160] → 100,973 ops/sec [99,366..101,295]	🔴 -1.9%	114,628 ops/sec [113,927..115,068] → 114,132 ops/sec [111,086..114,986]	~ overlap (-0.4%)
toString	152,383 ops/sec [150,864..153,893] → 154,285 ops/sec [152,405..155,645]	~ overlap (+1.2%)	182,900 ops/sec [181,320..187,182] → 181,409 ops/sec [180,875..183,191]	~ overlap (-0.8%)
valueOf	222,293 ops/sec [220,931..223,991] → 229,149 ops/sec [228,244..229,538]	🟢 +3.1%	275,566 ops/sec [272,558..276,628] → 264,084 ops/sec [261,212..265,363]	🔴 -4.2%
toPrecision	141,993 ops/sec [141,657..143,235] → 140,972 ops/sec [140,616..142,212]	~ overlap (-0.7%)	162,010 ops/sec [160,550..164,893] → 162,826 ops/sec [161,632..164,458]	~ overlap (+0.5%)
Number.isNaN	305,349 ops/sec [305,128..306,624] → 309,657 ops/sec [309,292..310,368]	🟢 +1.4%	332,560 ops/sec [331,889..333,498] → 324,055 ops/sec [323,554..324,864]	🔴 -2.6%
Number.isFinite	298,292 ops/sec [297,794..298,362] → 307,841 ops/sec [303,765..314,220]	🟢 +3.2%	313,583 ops/sec [309,562..316,746] → 307,189 ops/sec [305,898..310,294]	~ overlap (-2.0%)
Number.isInteger	311,046 ops/sec [308,723..312,798] → 314,232 ops/sec [311,458..316,501]	~ overlap (+1.0%)	338,902 ops/sec [334,071..340,262] → 328,289 ops/sec [327,469..331,065]	🔴 -3.1%
Number.parseInt and parseFloat	247,579 ops/sec [246,331..248,926] → 246,141 ops/sec [244,723..247,120]	~ overlap (-0.6%)	255,816 ops/sec [254,821..256,261] → 258,627 ops/sec [257,784..259,303]	🟢 +1.1%

objects.js — Interp: 🟢 3, 🔴 1, 3 unch. · avg +1.0% · Bytecode: 🟢 4, 🔴 1, 2 unch. · avg +1.8%

Benchmark	Interpreted	Δ	Bytecode	Δ
create simple object	469,666 ops/sec [466,940..474,272] → 481,658 ops/sec [477,964..485,027]	🟢 +2.6%	561,977 ops/sec [556,042..575,478] → 585,463 ops/sec [583,520..587,404]	🟢 +4.2%
create nested object	231,366 ops/sec [229,747..232,757] → 233,175 ops/sec [232,589..235,691]	~ overlap (+0.8%)	254,255 ops/sec [252,944..255,763] → 259,982 ops/sec [257,275..261,809]	🟢 +2.3%
create 50 objects via Array.from	9,217 ops/sec [9,186..9,287] → 9,525 ops/sec [9,476..9,621]	🟢 +3.3%	9,657 ops/sec [9,612..9,676] → 10,303 ops/sec [10,257..10,366]	🟢 +6.7%
property read	558,738 ops/sec [550,014..566,960] → 523,314 ops/sec [520,056..524,621]	🔴 -6.3%	434,072 ops/sec [431,015..439,921] → 416,990 ops/sec [415,161..419,144]	🔴 -3.9%
Object.keys	279,623 ops/sec [278,529..282,366] → 287,008 ops/sec [282,156..288,500]	~ overlap (+2.6%)	303,982 ops/sec [297,182..310,459] → 311,799 ops/sec [309,077..312,945]	~ overlap (+2.6%)
Object.entries	102,718 ops/sec [101,658..103,866] → 102,384 ops/sec [101,983..102,461]	~ overlap (-0.3%)	112,001 ops/sec [108,085..112,169] → 108,899 ops/sec [107,878..110,341]	~ overlap (-2.8%)
spread operator	176,782 ops/sec [176,041..177,826] → 184,265 ops/sec [183,716..184,846]	🟢 +4.2%	203,513 ops/sec [202,065..205,580] → 210,339 ops/sec [208,501..211,901]	🟢 +3.4%

promises.js — Interp: 🟢 4, 8 unch. · avg +1.2% · Bytecode: 🟢 3, 🔴 2, 7 unch. · avg +0.7%

Benchmark	Interpreted	Δ	Bytecode	Δ
Promise.resolve(value)	544,688 ops/sec [542,141..546,864] → 540,489 ops/sec [527,729..544,013]	~ overlap (-0.8%)	549,012 ops/sec [545,011..555,482] → 544,067 ops/sec [540,740..549,654]	~ overlap (-0.9%)
new Promise(resolve => resolve(value))	190,138 ops/sec [188,579..192,337] → 190,012 ops/sec [189,172..190,279]	~ overlap (-0.1%)	225,614 ops/sec [224,393..228,023] → 225,010 ops/sec [222,481..225,892]	~ overlap (-0.3%)
Promise.reject(reason)	557,749 ops/sec [554,046..565,364] → 549,056 ops/sec [547,260..556,106]	~ overlap (-1.6%)	535,157 ops/sec [515,382..546,946] → 535,258 ops/sec [532,118..540,456]	~ overlap (+0.0%)
resolve + then (1 handler)	175,684 ops/sec [174,986..176,354] → 176,831 ops/sec [176,159..177,073]	~ overlap (+0.7%)	189,283 ops/sec [187,539..193,261] → 197,399 ops/sec [196,434..198,390]	🟢 +4.3%
resolve + then chain (3 deep)	69,331 ops/sec [68,431..69,998] → 69,969 ops/sec [69,551..70,435]	~ overlap (+0.9%)	76,294 ops/sec [74,665..77,216] → 76,680 ops/sec [76,553..76,778]	~ overlap (+0.5%)
resolve + then chain (10 deep)	21,263 ops/sec [21,176..21,340] → 22,683 ops/sec [22,543..22,821]	🟢 +6.7%	24,380 ops/sec [24,177..24,738] → 25,316 ops/sec [25,101..25,402]	🟢 +3.8%
reject + catch + then	98,558 ops/sec [97,195..99,175] → 100,257 ops/sec [99,950..100,360]	🟢 +1.7%	107,430 ops/sec [106,594..109,722] → 109,430 ops/sec [108,461..110,756]	~ overlap (+1.9%)
resolve + finally + then	84,973 ops/sec [84,030..85,582] → 85,116 ops/sec [84,969..85,186]	~ overlap (+0.2%)	90,188 ops/sec [90,014..90,727] → 92,286 ops/sec [91,820..92,401]	🟢 +2.3%
Promise.all (5 resolved)	31,131 ops/sec [31,012..31,215] → 31,617 ops/sec [31,401..31,924]	🟢 +1.6%	32,636 ops/sec [32,581..32,715] → 32,436 ops/sec [32,220..32,539]	🔴 -0.6%
Promise.race (5 resolved)	33,141 ops/sec [32,885..33,402] → 33,628 ops/sec [33,580..33,661]	🟢 +1.5%	34,370 ops/sec [34,029..34,837] → 34,465 ops/sec [34,177..34,685]	~ overlap (+0.3%)
Promise.allSettled (5 mixed)	26,548 ops/sec [26,032..26,735] → 26,939 ops/sec [26,688..27,122]	~ overlap (+1.5%)	27,755 ops/sec [27,431..28,055] → 27,018 ops/sec [26,585..27,159]	🔴 -2.7%
Promise.any (5 mixed)	31,432 ops/sec [31,149..31,735] → 32,092 ops/sec [31,606..32,314]	~ overlap (+2.1%)	32,555 ops/sec [32,310..32,573] → 32,654 ops/sec [32,520..32,746]	~ overlap (+0.3%)

strings.js — Interp: 🟢 1, 🔴 1, 9 unch. · avg -0.2% · Bytecode: 🟢 1, 🔴 9, 1 unch. · avg -2.9%

Benchmark	Interpreted	Δ	Bytecode	Δ
string concatenation	406,744 ops/sec [401,017..409,000] → 403,083 ops/sec [401,343..404,379]	~ overlap (-0.9%)	316,309 ops/sec [314,903..319,581] → 309,711 ops/sec [309,063..309,827]	🔴 -2.1%
template literal	680,153 ops/sec [671,954..688,607] → 647,133 ops/sec [638,290..650,652]	🔴 -4.9%	641,686 ops/sec [639,341..643,050] → 647,677 ops/sec [645,441..650,136]	🟢 +0.9%
string repeat	400,117 ops/sec [398,791..402,744] → 399,082 ops/sec [397,900..400,854]	~ overlap (-0.3%)	463,964 ops/sec [462,795..466,644] → 443,386 ops/sec [439,606..446,628]	🔴 -4.4%
split and join	133,893 ops/sec [132,870..135,040] → 137,570 ops/sec [137,488..137,646]	🟢 +2.7%	153,583 ops/sec [152,469..156,218] → 154,709 ops/sec [152,137..155,754]	~ overlap (+0.7%)
indexOf and includes	164,598 ops/sec [163,704..165,918] → 165,086 ops/sec [163,870..165,362]	~ overlap (+0.3%)	189,430 ops/sec [188,224..189,631] → 180,485 ops/sec [179,838..180,775]	🔴 -4.7%
toUpperCase and toLowerCase	257,463 ops/sec [254,399..258,452] → 256,254 ops/sec [253,615..257,223]	~ overlap (-0.5%)	330,666 ops/sec [329,010..331,452] → 323,950 ops/sec [320,278..324,969]	🔴 -2.0%
slice and substring	151,628 ops/sec [151,232..152,899] → 153,090 ops/sec [152,649..153,530]	~ overlap (+1.0%)	201,777 ops/sec [200,095..209,823] → 190,837 ops/sec [189,474..191,209]	🔴 -5.4%
trim operations	190,406 ops/sec [188,628..191,679] → 191,649 ops/sec [190,647..192,783]	~ overlap (+0.7%)	246,052 ops/sec [243,874..247,938] → 236,890 ops/sec [235,445..240,874]	🔴 -3.7%
replace and replaceAll	211,214 ops/sec [209,999..211,843] → 209,711 ops/sec [207,926..211,296]	~ overlap (-0.7%)	237,843 ops/sec [236,570..243,229] → 230,718 ops/sec [229,378..230,856]	🔴 -3.0%
startsWith and endsWith	132,917 ops/sec [129,798..134,135] → 132,516 ops/sec [131,366..132,883]	~ overlap (-0.3%)	155,762 ops/sec [153,811..156,253] → 149,399 ops/sec [148,746..150,406]	🔴 -4.1%
padStart and padEnd	193,592 ops/sec [166,469..197,637] → 194,943 ops/sec [193,872..196,160]	~ overlap (+0.7%)	233,076 ops/sec [231,862..234,888] → 222,734 ops/sec [221,545..223,760]	🔴 -4.4%

typed-arrays.js — Interp: 🟢 11, 🔴 1, 10 unch. · avg +1.0% · Bytecode: 🟢 4, 🔴 10, 8 unch. · avg -0.9%

Benchmark	Interpreted	Δ	Bytecode	Δ
new Int32Array(0)	328,649 ops/sec [327,827..329,060] → 334,015 ops/sec [332,361..337,249]	🟢 +1.6%	365,282 ops/sec [363,711..365,849] → 356,912 ops/sec [354,761..357,473]	🔴 -2.3%
new Int32Array(100)	298,049 ops/sec [292,941..299,333] → 302,133 ops/sec [300,601..304,403]	🟢 +1.4%	325,805 ops/sec [321,473..328,434] → 327,350 ops/sec [325,441..330,142]	~ overlap (+0.5%)
new Int32Array(1000)	181,810 ops/sec [180,714..183,343] → 181,355 ops/sec [179,774..182,930]	~ overlap (-0.3%)	196,838 ops/sec [194,885..197,650] → 191,439 ops/sec [189,932..194,128]	🔴 -2.7%
new Float64Array(100)	270,955 ops/sec [269,910..272,792] → 272,268 ops/sec [271,238..274,324]	~ overlap (+0.5%)	306,983 ops/sec [306,332..307,168] → 296,254 ops/sec [294,622..297,256]	🔴 -3.5%
Int32Array.from([...])	180,491 ops/sec [178,452..180,953] → 170,153 ops/sec [169,579..170,409]	🔴 -5.7%	196,953 ops/sec [193,520..198,211] → 175,754 ops/sec [173,306..177,458]	🔴 -10.8%
Int32Array.of(1, 2, 3, 4, 5)	305,131 ops/sec [303,361..308,315] → 309,731 ops/sec [305,726..311,057]	~ overlap (+1.5%)	359,336 ops/sec [357,544..361,998] → 357,311 ops/sec [354,467..358,803]	~ overlap (-0.6%)
sequential write 100 elements	3,496 ops/sec [3,464..3,567] → 3,521 ops/sec [3,501..3,550]	~ overlap (+0.7%)	15,949 ops/sec [15,727..16,099] → 15,542 ops/sec [15,448..15,628]	🔴 -2.6%
sequential read 100 elements	3,611 ops/sec [3,576..3,629] → 3,591 ops/sec [3,583..3,614]	~ overlap (-0.6%)	10,970 ops/sec [10,816..11,055] → 10,866 ops/sec [10,725..11,013]	~ overlap (-1.0%)
Float64Array write 100 elements	3,293 ops/sec [3,283..3,306] → 3,264 ops/sec [3,239..3,302]	~ overlap (-0.9%)	11,145 ops/sec [10,962..11,228] → 10,994 ops/sec [10,868..11,102]	~ overlap (-1.3%)
fill(42)	46,721 ops/sec [46,612..46,809] → 48,400 ops/sec [48,386..48,422]	🟢 +3.6%	47,232 ops/sec [47,153..47,253] → 48,602 ops/sec [48,573..48,656]	🟢 +2.9%
slice()	199,559 ops/sec [197,579..200,873] → 203,579 ops/sec [202,750..204,064]	🟢 +2.0%	221,275 ops/sec [219,950..221,956] → 218,412 ops/sec [217,171..219,236]	🔴 -1.3%
map(x => x * 2)	7,780 ops/sec [7,768..7,791] → 8,115 ops/sec [8,038..8,142]	🟢 +4.3%	8,530 ops/sec [8,446..8,642] → 8,926 ops/sec [8,847..8,981]	🟢 +4.7%
filter(x => x > 50)	8,071 ops/sec [7,942..8,140] → 8,280 ops/sec [8,219..8,373]	🟢 +2.6%	9,516 ops/sec [9,460..9,593] → 9,921 ops/sec [9,850..9,970]	🟢 +4.3%
reduce (sum)	7,829 ops/sec [7,813..7,831] → 7,980 ops/sec [7,914..8,119]	🟢 +1.9%	7,271 ops/sec [7,230..7,318] → 7,417 ops/sec [7,336..7,471]	🟢 +2.0%
sort()	171,486 ops/sec [170,730..172,077] → 174,194 ops/sec [173,781..174,430]	🟢 +1.6%	173,253 ops/sec [172,899..173,362] → 171,535 ops/sec [171,068..171,919]	🔴 -1.0%
indexOf()	419,173 ops/sec [417,671..421,841] → 422,689 ops/sec [419,295..423,617]	~ overlap (+0.8%)	494,873 ops/sec [491,957..495,863] → 481,992 ops/sec [479,097..483,387]	🔴 -2.6%
reverse()	320,290 ops/sec [316,827..322,469] → 329,535 ops/sec [327,044..330,910]	🟢 +2.9%	354,425 ops/sec [353,955..354,720] → 349,754 ops/sec [349,672..349,877]	🔴 -1.3%
create view over existing buffer	399,067 ops/sec [396,817..401,433] → 397,657 ops/sec [396,889..401,076]	~ overlap (-0.4%)	439,463 ops/sec [436,878..443,200] → 434,164 ops/sec [433,486..437,801]	~ overlap (-1.2%)
subarray()	420,420 ops/sec [415,978..424,116] → 421,662 ops/sec [418,970..424,478]	~ overlap (+0.3%)	515,055 ops/sec [507,424..527,081] → 511,003 ops/sec [509,678..512,459]	~ overlap (-0.8%)
set() from array	551,221 ops/sec [548,326..553,509] → 562,462 ops/sec [555,880..566,830]	🟢 +2.0%	643,695 ops/sec [642,701..643,998] → 624,109 ops/sec [622,313..625,829]	🔴 -3.0%
for-of loop	4,922 ops/sec [4,915..4,933] → 4,989 ops/sec [4,978..5,029]	🟢 +1.4%	17,911 ops/sec [17,734..18,129] → 17,902 ops/sec [17,786..17,997]	~ overlap (-0.1%)
spread into array	17,357 ops/sec [17,238..17,499] → 17,503 ops/sec [17,330..17,589]	~ overlap (+0.8%)	96,395 ops/sec [95,396..97,750] → 98,052 ops/sec [97,102..99,868]	~ overlap (+1.7%)

_{Measured on ubuntu-latest x64. Benchmark ranges compare cached main-branch min/max ops/sec with the PR run; overlapping ranges are treated as unchanged noise. Percentage deltas are secondary context.}