Skip to content

fix(parser): make speculative paren-group probes template-aware#901

Merged
frostney merged 1 commit into
mainfrom
claude/vigilant-dubinsky-2e22bf
Jun 28, 2026
Merged

fix(parser): make speculative paren-group probes template-aware#901
frostney merged 1 commit into
mainfrom
claude/vigilant-dubinsky-2e22bf

Conversation

@frostney

Copy link
Copy Markdown
Owner

Summary

  • Fix a pre-existing parser bug: template literals with substitutions (`…${expr}…`) raised a spurious "Unterminated template literal" or "Unterminated regular expression literal" error when they appeared inside a speculatively-probed parenthesized group.
  • The four speculative parenthesized-group probes counted braces flatly. A template ${…} substitution's closing } is lexed as a plain gttRightBrace under any non-template goal, so the probes miscounted it as a structural brace; the following backtick then started a runaway template/regex. Affected probes: arrow-vs-paren disambiguation (SkipExpressionWithLexicalGoal / SkipDestructuringPattern), IsMatchExpressionAhead, and LooksLikeTraditionalForHeader.
  • Fix: route templates through the existing SkipTemplateLiteral, which re-lexes the substitution closer under the template-tail goal (matching the parser-owned lexical-goal model in docs/architecture.md). Its substitution scan is now operand-aware so a / inside ${…} is classified as division vs. regex exactly as the real parse would — otherwise a runaway regex swallowed the } (this was a second goal-sensitivity beyond the } itself, surfaced by the match/arrow-with-division repros). The duplicated TokenRequiresFollowingOperand is promoted to a shared method.

Failing examples (all green after this change):

const h = (t = `a${1 + 2}b`) => t;          // was: Unterminated template literal
const f = (label = `d=${6 / 2}`) => label;  // was: Unterminated regular expression literal
const g = ({ a = `x${1}y` }) => a;          // was: Unterminated template literal
match (`n=${4 / 2}`) { "n=2": "two"; default: "other"; };  // was: `match` mis-parsed
for (let s = `v${1}w`; s.length > 0; s = s.slice(1)) {}    // was: silently skipped (compat flag)

Constraints / non-goals: No change to the #896 goal-sensitivity contract — a template-tail } is goal-sensitive, so these probes still drop their cached tokens and let the real parse re-lex the template (this PR fixes the brace-counting within the probe scan). Pre-existing bug; reproduces on origin/main, independent of #896.

Testing

  • Verified no regressions and confirmed the new feature or bugfix in end-to-end JavaScript/TypeScript tests
  • Updated documentation
  • Optional: Verified no regressions and confirmed the new feature or bugfix in native Pascal tests (if AST, scope, evaluator, or value types changed)
  • Optional: Verified no benchmark regressions or confirmed benchmark coverage for the change

Full suite 11024/11024 passing in both modes:

./build/GocciaTestRunner tests                 # 11024 passed, 0 failed
./build/GocciaTestRunner tests --mode=bytecode  # 11024 passed, 0 failed
./format.pas --check                            # 374 files, all formatted correctly

New regression tests (22 tests) cover arrow/destructuring defaults, match discriminants, parenthesized expressions, and the compat-gated traditional-for header, plus operand-awareness edge cases (regex- and division-in-substitution, nested templates, tagged-template defaults). Documentation unchanged: this fixes parser behavior to match the existing lexical-goal model rather than introducing new surface. No AST/scope/evaluator/value-type changes, so native Pascal tests N/A; no expected benchmark impact.

🤖 Generated with Claude Code

The four speculative parenthesized-group probes — arrow-vs-paren
disambiguation (SkipExpressionWithLexicalGoal / SkipDestructuringPattern),
IsMatchExpressionAhead, and LooksLikeTraditionalForHeader — counted braces
flatly. A template `${...}` substitution's closing `}` is lexed as a plain
gttRightBrace under any non-template goal, so the probes miscounted it as a
structural brace and the following backtick started a runaway template/regex,
producing a spurious "Unterminated template literal" or "Unterminated regular
expression literal" parse error.

Route templates through SkipTemplateLiteral so the substitution closer is
re-lexed under the template-tail goal, and make its substitution scan
operand-aware so a `/` inside `${...}` is classified as division vs regex
exactly as the real parse would (otherwise a runaway regex swallowed the `}`).
Promote the duplicated TokenRequiresFollowingOperand to a shared method.

Pre-existing (fails on origin/main); independent of #896.

Add JS regression tests for arrow and destructuring defaults, match
discriminants, parenthesized expressions, and the compat-gated traditional-for
header, plus operand-awareness edge cases (regex/division in substitution,
nested templates, tagged-template defaults).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
@vercel

vercel Bot commented Jun 28, 2026

Copy link
Copy Markdown

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

1 Skipped Deployment
Project Deployment Actions Updated (UTC)
gocciascript-homepage Ignored Ignored Jun 28, 2026 3:16pm

Request Review

@coderabbitai

coderabbitai Bot commented Jun 28, 2026

Copy link
Copy Markdown
Contributor

Review Change Stack

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info
⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro Plus

Run ID: 585db058-799b-482a-ba25-112a36ac73a7

📥 Commits

Reviewing files that changed from the base of the PR and between 0f2734d and 74535d7.

📒 Files selected for processing (4)
  • source/units/Goccia.Parser.pas
  • tests/language/expressions/string/template-interpolation-speculative-probes.js
  • tests/language/for-loop/traditional-for-template-init.js
  • tests/language/functions/arrow-default-template-interpolation.js

📝 Walkthrough

Walkthrough

TGocciaParser gains a shared TokenRequiresFollowingOperand class helper, replacing duplicated local implementations. SkipTemplateLiteral is reworked with an operand-aware substitution loop using a depth counter and recursive template nesting. Four speculative probe methods (IsMatchExpressionAhead, LooksLikeTraditionalForHeader, SkipDestructuringPattern, SkipExpressionWithLexicalGoal) are patched to route template literals through SkipTemplateLiteral. Three new test files cover the affected paths.

Changes

Template literal substitution brace safety in speculative parsers

Layer / File(s) Summary
TokenRequiresFollowingOperand shared helper
source/units/Goccia.Parser.pas
Declares and implements TokenRequiresFollowingOperand as a class-private method; removes the previously duplicated local helpers from SkipDestructuringPattern and SkipExpressionWithLexicalGoal.
SkipTemplateLiteral operand-aware substitution loop
source/units/Goccia.Parser.pas
Introduces NeedsOperand/CurrentType state and replaces the simplistic loop with an operand-aware one that calls TokenRequiresFollowingOperand, recurses for nested templates, and uses a Depth counter to identify the correct closing }.
Speculative probe paths patched
source/units/Goccia.Parser.pas
IsMatchExpressionAhead, LooksLikeTraditionalForHeader, SkipDestructuringPattern, and SkipExpressionWithLexicalGoal each detect template literals in their scanning loops and delegate to SkipTemplateLiteral to avoid miscounting substitution } as structural braces.
New tests
tests/language/expressions/string/template-interpolation-speculative-probes.js, tests/language/for-loop/traditional-for-template-init.js, tests/language/functions/arrow-default-template-interpolation.js
Covers template literals with substitutions in parenthesized expression probes, match discriminants, traditional for initializers, and arrow function parameter defaults including destructuring.

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~45 minutes

Possibly related PRs

  • frostney/GocciaScript#267: Adds ParseTaggedTemplate with nested ${ } brace counting, directly overlapping with this PR's rework of SkipTemplateLiteral substitution depth tracking.
  • frostney/GocciaScript#889: Modifies SkipTemplateLiteral and its integration into skip/probe helpers in the same file, making it a direct predecessor to this PR's changes.
  • frostney/GocciaScript#896: Updates the same speculative probe functions (IsMatchExpressionAhead etc.) to be lexical-goal aware around / and template substitution }, closely related to this PR's operand-aware goal selection work.

Suggested labels

bug, spec compliance

🚥 Pre-merge checks | ✅ 5
✅ Passed checks (5 passed)
Check name Status Explanation
Title check ✅ Passed The title clearly summarizes the parser bug fix and its main scope.
Description check ✅ Passed The description matches the template with Summary and Testing sections and includes the key implementation and test details.
Docstring Coverage ✅ Passed No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.
Linked Issues check ✅ Passed Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check ✅ Passed Check skipped because no linked issues were found for this pull request.

Warning

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

🔧 Biome (2.5.0)
tests/language/expressions/string/template-interpolation-speculative-probes.js

File contains syntax errors that prevent linting: Line 25: Expected a semicolon or an implicit semicolon after a statement, but found none; Line 26: Expected a semicolon or an implicit semicolon after a statement, but found none; Line 27: Expected a statement but instead found 'default: "other"'.; Line 33: Expected a semicolon or an implicit semicolon after a statement, but found none; Line 34: Expected a semicolon or an implicit semicolon after a statement, but found none; Line 35: Expected a statement but instead found 'default: "no"'.; Line 41: Expected a semicolon or an implicit semicolon after a statement, but found none; Line 42: Expected a semicolon or an implicit semicolon after a statement, but found none; Line 43: Expected a statement but instead found 'default: "miss"'.; Line 49: Expected a semicolon or an implicit semicolon after a statement, but found none; Line 50: Expected a semicolon or an implicit semicolon after a statement, but found none; Line 51: Expected a statement but instead found 'default: "no"'.


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

@coderabbitai coderabbitai Bot added bug Something isn't working spec compliance Mismatch against official JavaScript/TypeScript specification labels Jun 28, 2026
@github-actions

Copy link
Copy Markdown
Contributor

Suite Timing

Test Runner (interpreted: 11,024 passed; bytecode: 11,024 passed)
Metric Interpreted Bytecode
Total 11024 11024
Passed 11024 ✅ 11024 ✅
Workers 4 4
Test Duration 19.73s 18.43s
Lex (cumulative) 491.8ms 507.5ms
Parse (cumulative) 364.7ms 350.0ms
Compile (cumulative) 712.2ms
Execute (cumulative) 110.2ms 43.20s
Engine Total (cumulative) 966.8ms 44.77s
Lex (avg/worker) 122.9ms 126.9ms
Parse (avg/worker) 91.2ms 87.5ms
Compile (avg/worker) 178.1ms
Execute (avg/worker) 27.6ms 10.80s
Engine Total (avg/worker) 241.7ms 11.19s

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.59 MiB 280.99 MiB
GC Peak Live 342.93 MiB 353.89 MiB
GC Allocated During Run 530.35 MiB 474.47 MiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 195 195
GC Collected Objects 2,601,062 2,171,037
Heap Start Allocated 182.5 KiB 182.5 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: 436; bytecode: 436)
Metric Interpreted Bytecode
Total 436 436
Workers 4 4
Duration 2.96min 2.79min

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 102.98 MiB 72.41 MiB
GC Allocated During Run 16.72 GiB 9.86 GiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 3,600 3,674
GC Collected Objects 263,460,144 222,563,364
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

Copy link
Copy Markdown
Contributor

Benchmark Results

436 benchmarks · PR vs same-runner main build

Interpreted: 🟢 16 improved · 🔴 27 regressed · 393 unchanged · avg -0.2%
Bytecode: 🟢 23 improved · 🔴 47 regressed · 366 unchanged · avg +0.0%

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

arraybuffer.js — Interp: 🔴 1, 13 unch. · avg +0.2% · Bytecode: 🔴 1, 13 unch. · avg -0.0%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
create ArrayBuffer(0) 133,941 ops/sec [115,866..175,486] → 131,297 ops/sec [128,172..132,983] ~ overlap (-2.0%) 147,998 ops/sec [146,178..149,940] → 144,209 ops/sec [123,504..155,383] ~ overlap (-2.6%)
create ArrayBuffer(64) 128,769 ops/sec [126,067..129,194] → 125,592 ops/sec [125,046..126,963] ~ overlap (-2.5%) 144,465 ops/sec [140,846..144,657] → 144,829 ops/sec [139,932..186,282] ~ overlap (+0.3%)
create ArrayBuffer(1024) 116,233 ops/sec [112,445..153,364] → 114,522 ops/sec [108,343..128,787] ~ overlap (-1.5%) 129,166 ops/sec [93,602..134,847] → 127,986 ops/sec [118,455..144,273] ~ overlap (-0.9%)
create ArrayBuffer(8192) 69,256 ops/sec [66,408..73,824] → 68,660 ops/sec [66,312..70,680] ~ overlap (-0.9%) 78,178 ops/sec [74,877..85,100] → 81,576 ops/sec [72,838..92,511] ~ overlap (+4.3%)
slice full buffer (64 bytes) 109,569 ops/sec [107,409..113,476] → 118,866 ops/sec [108,535..125,554] ~ overlap (+8.5%) 119,593 ops/sec [119,358..120,269] → 116,878 ops/sec [116,640..117,322] 🔴 -2.3%
slice half buffer (512 of 1024 bytes) 101,825 ops/sec [101,316..102,348] → 102,225 ops/sec [100,928..121,757] ~ overlap (+0.4%) 108,933 ops/sec [106,869..109,866] → 110,036 ops/sec [108,131..111,284] ~ overlap (+1.0%)
slice with negative indices 94,385 ops/sec [92,836..94,580] → 99,313 ops/sec [93,857..104,327] ~ overlap (+5.2%) 114,418 ops/sec [110,676..138,133] → 112,362 ops/sec [111,843..113,371] ~ overlap (-1.8%)
slice empty range 106,229 ops/sec [74,177..106,881] → 104,020 ops/sec [103,878..104,577] ~ overlap (-2.1%) 115,447 ops/sec [114,884..116,237] → 115,204 ops/sec [114,684..122,613] ~ overlap (-0.2%)
byteLength access 302,212 ops/sec [295,532..322,070] → 299,934 ops/sec [295,117..303,396] ~ overlap (-0.8%) 339,632 ops/sec [324,675..344,524] → 337,892 ops/sec [333,082..345,187] ~ overlap (-0.5%)
Symbol.toStringTag access 255,821 ops/sec [239,830..262,730] → 237,141 ops/sec [229,596..285,317] ~ overlap (-7.3%) 247,899 ops/sec [239,663..276,337] → 240,513 ops/sec [238,596..255,758] ~ overlap (-3.0%)
ArrayBuffer.isView 190,288 ops/sec [189,201..190,844] → 186,182 ops/sec [182,899..189,119] 🔴 -2.2% 229,587 ops/sec [228,311..237,399] → 230,046 ops/sec [229,555..230,808] ~ overlap (+0.2%)
clone ArrayBuffer(64) 139,486 ops/sec [138,012..142,671] → 148,213 ops/sec [138,608..148,929] ~ overlap (+6.3%) 166,857 ops/sec [161,695..174,396] → 167,592 ops/sec [166,131..173,975] ~ overlap (+0.4%)
clone ArrayBuffer(1024) 121,658 ops/sec [121,217..145,120] → 122,054 ops/sec [121,729..122,671] ~ overlap (+0.3%) 143,504 ops/sec [141,912..172,509] → 148,764 ops/sec [143,771..159,262] ~ overlap (+3.7%)
clone ArrayBuffer inside object 92,678 ops/sec [91,772..95,158] → 93,607 ops/sec [92,235..93,919] ~ overlap (+1.0%) 100,325 ops/sec [100,106..103,105] → 101,643 ops/sec [100,883..101,906] ~ overlap (+1.3%)
arrays.js — Interp: 🔴 1, 18 unch. · avg -1.3% · Bytecode: 🟢 1, 🔴 1, 17 unch. · avg +0.9%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
Array.from length 100 3,841 ops/sec [3,546..4,029] → 3,659 ops/sec [3,621..3,915] ~ overlap (-4.7%) 2,935 ops/sec [2,750..2,989] → 2,971 ops/sec [2,828..3,538] ~ overlap (+1.2%)
Array.from 10 elements 73,837 ops/sec [73,281..75,621] → 74,062 ops/sec [72,374..77,493] ~ overlap (+0.3%) 71,991 ops/sec [69,433..79,334] → 72,957 ops/sec [71,789..86,122] ~ overlap (+1.3%)
Array.of 10 elements 95,147 ops/sec [93,476..95,489] → 97,093 ops/sec [67,521..131,232] ~ overlap (+2.0%) 105,195 ops/sec [102,325..128,665] → 106,952 ops/sec [104,059..145,676] ~ overlap (+1.7%)
spread into new array 108,249 ops/sec [106,648..112,607] → 108,158 ops/sec [106,052..117,586] ~ overlap (-0.1%) 52,933 ops/sec [52,614..58,745] → 54,470 ops/sec [51,759..56,023] ~ overlap (+2.9%)
map over 50 elements 5,643 ops/sec [5,598..6,208] → 5,811 ops/sec [5,665..5,976] ~ overlap (+3.0%) 6,104 ops/sec [5,714..6,276] → 5,714 ops/sec [5,528..5,850] ~ overlap (-6.4%)
filter over 50 elements 5,429 ops/sec [5,393..5,441] → 5,649 ops/sec [5,395..6,414] ~ overlap (+4.0%) 5,621 ops/sec [5,584..6,565] → 5,703 ops/sec [5,551..5,742] ~ overlap (+1.4%)
reduce sum 50 elements 5,843 ops/sec [5,239..5,905] → 5,845 ops/sec [5,387..6,114] ~ overlap (+0.0%) 5,517 ops/sec [5,471..6,972] → 6,327 ops/sec [5,558..6,890] ~ overlap (+14.7%)
forEach over 50 elements 3,941 ops/sec [3,903..4,023] → 3,960 ops/sec [3,841..4,006] ~ overlap (+0.5%) 6,039 ops/sec [5,983..6,054] → 5,761 ops/sec [5,722..7,102] ~ overlap (-4.6%)
find in 50 elements 7,836 ops/sec [7,693..8,382] → 7,818 ops/sec [7,730..8,241] ~ overlap (-0.2%) 7,737 ops/sec [7,621..7,767] → 7,613 ops/sec [7,596..7,615] 🔴 -1.6%
sort 20 elements 4,756 ops/sec [4,723..4,800] → 5,011 ops/sec [4,585..5,272] ~ overlap (+5.4%) 4,962 ops/sec [4,930..4,987] → 5,069 ops/sec [5,030..5,300] 🟢 +2.2%
flat nested array 46,636 ops/sec [44,534..49,806] → 44,753 ops/sec [43,953..45,787] ~ overlap (-4.0%) 43,961 ops/sec [43,901..44,315] → 44,248 ops/sec [44,213..47,214] ~ overlap (+0.7%)
flatMap 25,074 ops/sec [24,620..27,211] → 23,675 ops/sec [23,454..23,862] 🔴 -5.6% 23,619 ops/sec [23,258..23,857] → 23,846 ops/sec [23,710..23,961] ~ overlap (+1.0%)
map inside map (5x5) 6,325 ops/sec [6,268..6,355] → 6,331 ops/sec [6,291..6,346] ~ overlap (+0.1%) 6,191 ops/sec [5,591..6,358] → 6,234 ops/sec [6,199..7,062] ~ overlap (+0.7%)
filter inside map (5x10) 4,766 ops/sec [4,261..4,980] → 4,271 ops/sec [4,262..4,288] ~ overlap (-10.4%) 4,354 ops/sec [4,266..4,629] → 4,423 ops/sec [4,395..4,434] ~ overlap (+1.6%)
reduce inside map (5x10) 4,936 ops/sec [4,766..5,491] → 4,789 ops/sec [4,747..4,823] ~ overlap (-3.0%) 4,546 ops/sec [4,418..4,631] → 4,603 ops/sec [4,571..4,626] ~ overlap (+1.3%)
forEach inside forEach (5x10) 3,404 ops/sec [3,358..4,063] → 3,334 ops/sec [3,310..3,707] ~ overlap (-2.1%) 4,888 ops/sec [4,737..5,192] → 4,822 ops/sec [4,810..4,847] ~ overlap (-1.4%)
find inside some (10x10) 3,555 ops/sec [3,529..4,576] → 3,695 ops/sec [3,389..3,990] ~ overlap (+4.0%) 3,396 ops/sec [3,357..3,541] → 3,519 ops/sec [3,447..3,722] ~ overlap (+3.6%)
map+filter chain nested (5x20) 1,302 ops/sec [1,286..1,309] → 1,285 ops/sec [1,262..1,289] ~ overlap (-1.3%) 1,325 ops/sec [1,285..1,431] → 1,314 ops/sec [1,290..1,357] ~ overlap (-0.9%)
reduce flatten (10x5) 13,008 ops/sec [11,063..13,370] → 11,309 ops/sec [11,208..11,539] ~ overlap (-13.1%) 4,164 ops/sec [4,148..4,563] → 4,092 ops/sec [3,953..4,222] ~ overlap (-1.7%)
async-await.js — Interp: 6 unch. · avg +1.6% · Bytecode: 6 unch. · avg +2.7%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
single await 26,907 ops/sec [24,532..34,092] → 29,132 ops/sec [28,355..33,057] ~ overlap (+8.3%) 23,752 ops/sec [23,145..26,892] → 25,269 ops/sec [21,636..27,548] ~ overlap (+6.4%)
multiple awaits 11,282 ops/sec [10,512..11,859] → 11,169 ops/sec [10,428..12,101] ~ overlap (-1.0%) 8,156 ops/sec [6,097..10,535] → 8,251 ops/sec [7,913..9,122] ~ overlap (+1.2%)
await non-Promise value 35,047 ops/sec [33,788..40,939] → 34,354 ops/sec [34,106..36,396] ~ overlap (-2.0%) 29,978 ops/sec [28,422..34,243] → 29,805 ops/sec [28,832..30,494] ~ overlap (-0.6%)
await with try/catch 22,901 ops/sec [21,940..26,320] → 22,696 ops/sec [22,094..23,264] ~ overlap (-0.9%) 22,237 ops/sec [21,647..23,868] → 23,563 ops/sec [22,058..23,663] ~ overlap (+6.0%)
await Promise.all 6,053 ops/sec [5,990..6,072] → 6,345 ops/sec [5,852..6,645] ~ overlap (+4.8%) 5,541 ops/sec [5,376..5,963] → 5,726 ops/sec [5,313..6,074] ~ overlap (+3.3%)
nested async function call 14,890 ops/sec [14,143..14,922] → 14,962 ops/sec [13,198..16,050] ~ overlap (+0.5%) 13,396 ops/sec [13,267..13,694] → 13,357 ops/sec [13,235..13,940] ~ overlap (-0.3%)
async-generators.js — Interp: 2 unch. · avg -10.0% · Bytecode: 🔴 1, 1 unch. · avg -1.8%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
for-await-of over async generator 1,835 ops/sec [1,697..1,916] → 1,719 ops/sec [1,564..1,861] ~ overlap (-6.4%) 590 ops/sec [580..625] → 571 ops/sec [472..578] 🔴 -3.3%
async generator with await in body 13,844 ops/sec [11,946..16,494] → 11,948 ops/sec [11,794..12,111] ~ overlap (-13.7%) 4,369 ops/sec [4,149..4,382] → 4,353 ops/sec [4,220..5,838] ~ overlap (-0.4%)
atomics.js — Interp: 6 unch. · avg -2.8% · Bytecode: 🟢 1, 🔴 2, 3 unch. · avg -0.7%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
load and store Int32Array 93,098 ops/sec [88,687..93,331] → 93,649 ops/sec [92,694..94,305] ~ overlap (+0.6%) 117,931 ops/sec [115,547..121,572] → 124,668 ops/sec [121,721..136,582] 🟢 +5.7%
read-modify-write Int32Array 62,783 ops/sec [60,973..67,987] → 63,141 ops/sec [60,774..64,239] ~ overlap (+0.6%) 81,754 ops/sec [79,970..82,592] → 79,086 ops/sec [78,747..79,313] 🔴 -3.3%
compareExchange hit and miss 61,420 ops/sec [58,998..70,746] → 57,293 ops/sec [51,388..71,570] ~ overlap (-6.7%) 74,506 ops/sec [74,188..74,784] → 70,936 ops/sec [68,684..73,381] 🔴 -4.8%
wait with zero timeout 168,613 ops/sec [148,543..194,867] → 148,338 ops/sec [145,983..148,685] ~ overlap (-12.0%) 183,634 ops/sec [180,051..190,840] → 183,835 ops/sec [182,779..189,819] ~ overlap (+0.1%)
waitAsync synchronous not-equal 107,287 ops/sec [101,959..108,247] → 106,675 ops/sec [104,879..119,086] ~ overlap (-0.6%) 121,516 ops/sec [120,759..123,043] → 120,515 ops/sec [117,138..131,308] ~ overlap (-0.8%)
notify with no waiters 154,097 ops/sec [151,631..156,584] → 156,545 ops/sec [151,555..157,393] ~ overlap (+1.6%) 189,513 ops/sec [185,458..191,002] → 187,491 ops/sec [182,913..187,691] ~ overlap (-1.1%)
base64.js — Interp: 🟢 1, 9 unch. · avg +1.0% · Bytecode: 10 unch. · avg +1.6%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
short ASCII (13 chars) 2,641 ops/sec [1,957..2,689] → 2,680 ops/sec [2,647..2,691] ~ overlap (+1.5%) 2,373 ops/sec [2,346..2,380] → 2,362 ops/sec [2,352..2,367] ~ overlap (-0.5%)
medium ASCII (450 chars) 96 ops/sec [95..96] → 97 ops/sec [95..125] ~ overlap (+1.0%) 86 ops/sec [86..87] → 87 ops/sec [84..90] ~ overlap (+1.1%)
Latin-1 characters 3,952 ops/sec [3,921..3,959] → 3,890 ops/sec [3,734..5,170] ~ overlap (-1.5%) 3,417 ops/sec [3,370..3,444] → 3,940 ops/sec [3,389..4,933] ~ overlap (+15.3%)
short base64 (20 chars) 1,967 ops/sec [1,918..2,149] → 1,903 ops/sec [1,774..2,266] ~ overlap (-3.3%) 1,696 ops/sec [1,669..1,706] → 1,728 ops/sec [1,677..1,749] ~ overlap (+1.9%)
medium base64 (600 chars) 76 ops/sec [74..86] → 75 ops/sec [74..84] ~ overlap (-1.8%) 66 ops/sec [66..67] → 66 ops/sec [65..68] ~ overlap (+0.2%)
Latin-1 output 2,751 ops/sec [2,718..2,805] → 2,947 ops/sec [2,761..2,995] ~ overlap (+7.1%) 2,457 ops/sec [2,419..2,461] → 2,438 ops/sec [2,415..2,917] ~ overlap (-0.8%)
forgiving (no padding) 4,232 ops/sec [4,071..4,301] → 4,343 ops/sec [4,265..4,424] ~ overlap (+2.6%) 3,585 ops/sec [3,539..3,624] → 3,557 ops/sec [3,537..3,572] ~ overlap (-0.8%)
with whitespace 1,836 ops/sec [1,794..1,890] → 1,816 ops/sec [1,809..1,819] ~ overlap (-1.1%) 1,607 ops/sec [1,549..1,639] → 1,599 ops/sec [1,589..1,607] ~ overlap (-0.5%)
atob(btoa(short)) 1,099 ops/sec [1,092..1,109] → 1,113 ops/sec [1,104..1,124] ~ overlap (+1.2%) 1,017 ops/sec [976..1,038] → 1,038 ops/sec [994..1,111] ~ overlap (+2.0%)
atob(btoa(medium)) 42 ops/sec [42..42] → 44 ops/sec [43..49] 🟢 +4.5% 39 ops/sec [37..42] → 38 ops/sec [37..39] ~ overlap (-2.1%)
classes.js — Interp: 🟢 2, 🔴 1, 28 unch. · avg +0.4% · Bytecode: 🟢 2, 🔴 3, 26 unch. · avg +0.5%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
simple class new 44,633 ops/sec [41,282..50,279] → 48,411 ops/sec [46,902..50,121] ~ overlap (+8.5%) 51,928 ops/sec [51,779..52,522] → 51,799 ops/sec [51,403..52,362] ~ overlap (-0.3%)
class with defaults 34,947 ops/sec [27,174..40,578] → 35,476 ops/sec [33,898..37,552] ~ overlap (+1.5%) 35,622 ops/sec [34,831..41,376] → 35,752 ops/sec [35,170..35,855] ~ overlap (+0.4%)
50 instances via Array.from 1,524 ops/sec [1,495..1,546] → 1,593 ops/sec [1,550..1,956] 🟢 +4.5% 1,651 ops/sec [1,644..1,658] → 1,599 ops/sec [1,596..1,603] 🔴 -3.2%
instance method call 20,034 ops/sec [19,825..21,017] → 20,494 ops/sec [20,451..20,534] ~ overlap (+2.3%) 28,994 ops/sec [27,666..30,760] → 26,821 ops/sec [26,623..26,852] 🔴 -7.5%
static method call 37,258 ops/sec [33,709..42,522] → 34,763 ops/sec [34,658..34,863] ~ overlap (-6.7%) 61,263 ops/sec [55,958..74,564] → 56,817 ops/sec [55,628..62,913] ~ overlap (-7.3%)
single-level inheritance 18,544 ops/sec [17,939..22,552] → 18,056 ops/sec [17,949..18,343] ~ overlap (-2.6%) 19,620 ops/sec [18,685..21,727] → 20,673 ops/sec [19,434..22,709] ~ overlap (+5.4%)
two-level inheritance 15,593 ops/sec [15,307..15,712] → 15,781 ops/sec [15,577..18,485] ~ overlap (+1.2%) 16,130 ops/sec [14,740..19,500] → 14,928 ops/sec [14,816..15,040] ~ overlap (-7.5%)
private field access 22,611 ops/sec [22,400..24,129] → 23,627 ops/sec [22,345..24,310] ~ overlap (+4.5%) 14,786 ops/sec [14,682..15,349] → 14,730 ops/sec [14,546..16,355] ~ overlap (-0.4%)
private methods 25,146 ops/sec [24,883..25,248] → 25,466 ops/sec [25,027..25,894] ~ overlap (+1.3%) 16,590 ops/sec [16,482..16,684] → 16,556 ops/sec [16,464..16,666] ~ overlap (-0.2%)
getter/setter access 23,861 ops/sec [23,473..25,104] → 25,535 ops/sec [23,751..29,510] ~ overlap (+7.0%) 29,835 ops/sec [29,650..32,262] → 29,432 ops/sec [29,087..31,875] ~ overlap (-1.3%)
class decorator (identity) 41,415 ops/sec [35,598..50,950] → 38,365 ops/sec [35,658..41,093] ~ overlap (-7.4%) 33,847 ops/sec [33,422..36,391] → 33,506 ops/sec [26,982..37,041] ~ overlap (-1.0%)
class decorator (wrapping) 22,064 ops/sec [21,760..23,682] → 19,452 ops/sec [19,180..19,610] 🔴 -11.8% 17,762 ops/sec [17,571..18,359] → 17,579 ops/sec [17,462..20,297] ~ overlap (-1.0%)
identity method decorator 25,570 ops/sec [23,945..28,794] → 25,603 ops/sec [24,802..28,645] ~ overlap (+0.1%) 30,082 ops/sec [27,168..33,219] → 27,694 ops/sec [27,458..27,927] ~ overlap (-7.9%)
wrapping method decorator 20,068 ops/sec [19,698..22,281] → 20,202 ops/sec [20,072..20,274] ~ overlap (+0.7%) 20,577 ops/sec [20,428..21,403] → 20,875 ops/sec [20,793..21,010] ~ overlap (+1.4%)
stacked method decorators (x3) 14,595 ops/sec [13,891..16,825] → 14,561 ops/sec [14,297..16,021] ~ overlap (-0.2%) 14,890 ops/sec [14,749..16,555] → 14,850 ops/sec [14,777..14,918] ~ overlap (-0.3%)
identity field decorator 28,297 ops/sec [26,823..29,940] → 29,987 ops/sec [27,867..30,778] ~ overlap (+6.0%) 26,851 ops/sec [26,535..33,328] → 30,138 ops/sec [26,379..30,720] ~ overlap (+12.2%)
field initializer decorator 23,094 ops/sec [22,783..25,570] → 23,315 ops/sec [22,926..24,312] ~ overlap (+1.0%) 23,758 ops/sec [23,037..24,148] → 23,645 ops/sec [23,412..25,042] ~ overlap (-0.5%)
getter decorator (identity) 22,148 ops/sec [21,941..22,540] → 22,067 ops/sec [22,011..23,251] ~ overlap (-0.4%) 18,537 ops/sec [18,296..19,817] → 18,407 ops/sec [18,102..20,580] ~ overlap (-0.7%)
setter decorator (identity) 18,587 ops/sec [17,686..19,993] → 18,665 ops/sec [18,484..18,869] ~ overlap (+0.4%) 14,833 ops/sec [14,758..14,894] → 15,090 ops/sec [14,718..15,153] ~ overlap (+1.7%)
static method decorator 25,768 ops/sec [25,332..28,378] → 25,875 ops/sec [25,476..27,233] ~ overlap (+0.4%) 31,594 ops/sec [31,444..31,684] → 30,851 ops/sec [28,731..31,182] 🔴 -2.4%
static field decorator 30,751 ops/sec [30,427..30,980] → 34,061 ops/sec [32,696..41,293] 🟢 +10.8% 39,755 ops/sec [34,425..40,358] → 39,458 ops/sec [33,861..41,567] ~ overlap (-0.7%)
private method decorator 19,362 ops/sec [18,562..21,625] → 19,428 ops/sec [18,979..21,259] ~ overlap (+0.3%) 20,187 ops/sec [19,614..22,179] → 20,486 ops/sec [18,573..21,209] ~ overlap (+1.5%)
private field decorator 21,491 ops/sec [21,101..21,859] → 21,748 ops/sec [21,106..25,549] ~ overlap (+1.2%) 17,860 ops/sec [17,535..17,970] → 18,627 ops/sec [18,477..18,973] 🟢 +4.3%
plain auto-accessor (no decorator) 37,375 ops/sec [37,200..37,613] → 41,057 ops/sec [35,992..49,494] ~ overlap (+9.9%) 32,845 ops/sec [32,669..38,003] → 34,210 ops/sec [33,845..34,328] ~ overlap (+4.2%)
auto-accessor with decorator 21,893 ops/sec [21,255..21,922] → 21,149 ops/sec [20,706..21,486] ~ overlap (-3.4%) 20,085 ops/sec [19,988..22,850] → 20,049 ops/sec [19,210..21,025] ~ overlap (-0.2%)
decorator writing metadata 17,434 ops/sec [17,180..17,578] → 17,189 ops/sec [16,794..23,680] ~ overlap (-1.4%) 19,165 ops/sec [18,877..21,664] → 18,820 ops/sec [18,678..22,188] ~ overlap (-1.8%)
static getter read 42,343 ops/sec [40,041..54,718] → 40,816 ops/sec [40,594..41,895] ~ overlap (-3.6%) 52,925 ops/sec [51,400..54,727] → 53,068 ops/sec [52,647..53,550] ~ overlap (+0.3%)
static getter/setter pair 29,790 ops/sec [29,379..29,863] → 31,013 ops/sec [29,667..43,611] ~ overlap (+4.1%) 39,621 ops/sec [38,958..46,125] → 37,679 ops/sec [37,143..43,999] ~ overlap (-4.9%)
inherited static getter 26,014 ops/sec [25,667..26,185] → 25,946 ops/sec [25,663..26,112] ~ overlap (-0.3%) 33,417 ops/sec [33,141..35,020] → 40,230 ops/sec [33,100..45,664] ~ overlap (+20.4%)
inherited static setter 30,974 ops/sec [26,670..35,474] → 27,096 ops/sec [26,444..27,464] ~ overlap (-12.5%) 35,509 ops/sec [34,024..39,106] → 33,716 ops/sec [32,632..39,077] ~ overlap (-5.0%)
inherited static getter with this binding 21,162 ops/sec [20,335..21,659] → 20,810 ops/sec [20,065..21,373] ~ overlap (-1.7%) 26,948 ops/sec [26,686..30,502] → 31,709 ops/sec [31,127..34,698] 🟢 +17.7%
closures.js — Interp: 11 unch. · avg -1.6% · Bytecode: 🔴 1, 10 unch. · avg -1.8%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
closure over single variable 30,871 ops/sec [29,625..40,663] → 30,582 ops/sec [29,938..31,998] ~ overlap (-0.9%) 88,944 ops/sec [87,288..92,718] → 87,483 ops/sec [86,771..91,908] ~ overlap (-1.6%)
closure over multiple variables 38,862 ops/sec [38,629..39,938] → 38,602 ops/sec [38,306..44,186] ~ overlap (-0.7%) 84,028 ops/sec [83,752..87,018] → 85,135 ops/sec [83,041..85,972] ~ overlap (+1.3%)
nested closures 43,540 ops/sec [40,434..47,987] → 41,785 ops/sec [39,612..66,376] ~ overlap (-4.0%) 86,257 ops/sec [84,087..91,164] → 84,821 ops/sec [82,390..87,811] ~ overlap (-1.7%)
function as argument 32,391 ops/sec [31,968..34,102] → 31,258 ops/sec [30,413..35,133] ~ overlap (-3.5%) 87,583 ops/sec [80,115..91,155] → 79,329 ops/sec [79,066..79,724] 🔴 -9.4%
function returning function 40,520 ops/sec [38,823..41,292] → 39,621 ops/sec [39,432..39,881] ~ overlap (-2.2%) 99,862 ops/sec [94,100..107,684] → 98,342 ops/sec [98,126..102,089] ~ overlap (-1.5%)
compose two functions 25,270 ops/sec [24,810..25,531] → 25,490 ops/sec [25,196..25,608] ~ overlap (+0.9%) 57,187 ops/sec [56,874..57,861] → 57,204 ops/sec [56,729..57,553] ~ overlap (+0.0%)
fn.call 56,309 ops/sec [53,982..64,432] → 55,049 ops/sec [54,587..55,696] ~ overlap (-2.2%) 71,927 ops/sec [69,785..72,439] → 70,567 ops/sec [70,233..71,240] ~ overlap (-1.9%)
fn.apply 45,505 ops/sec [42,862..46,686] → 43,339 ops/sec [42,736..48,695] ~ overlap (-4.8%) 69,334 ops/sec [68,532..72,135] → 67,700 ops/sec [67,403..69,963] ~ overlap (-2.4%)
fn.bind 46,471 ops/sec [45,420..61,223] → 47,774 ops/sec [45,470..56,884] ~ overlap (+2.8%) 97,493 ops/sec [91,084..101,746] → 90,497 ops/sec [89,583..93,755] ~ overlap (-7.2%)
recursive sum to 50 3,842 ops/sec [3,796..3,860] → 3,805 ops/sec [3,670..3,924] ~ overlap (-1.0%) 12,642 ops/sec [11,725..13,705] → 13,381 ops/sec [11,760..14,489] ~ overlap (+5.8%)
recursive tree traversal 5,734 ops/sec [5,471..5,870] → 5,607 ops/sec [5,243..5,749] ~ overlap (-2.2%) 11,232 ops/sec [10,998..11,333] → 11,134 ops/sec [11,045..11,190] ~ overlap (-0.9%)
collections.js — Interp: 🔴 2, 10 unch. · avg -0.3% · Bytecode: 12 unch. · avg -1.2%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
add 50 elements 3,312 ops/sec [3,277..3,493] → 3,428 ops/sec [3,317..3,794] ~ overlap (+3.5%) 3,758 ops/sec [3,697..3,822] → 3,558 ops/sec [3,532..3,869] ~ overlap (-5.3%)
has lookup (50 elements) 71,548 ops/sec [69,773..73,059] → 71,307 ops/sec [69,880..81,169] ~ overlap (-0.3%) 97,578 ops/sec [96,454..103,095] → 97,586 ops/sec [97,117..98,714] ~ overlap (+0.0%)
delete elements 38,050 ops/sec [37,946..38,969] → 39,195 ops/sec [38,838..39,247] ~ overlap (+3.0%) 47,806 ops/sec [46,997..48,119] → 47,352 ops/sec [47,201..50,893] ~ overlap (-1.0%)
forEach iteration 4,307 ops/sec [4,127..4,760] → 4,948 ops/sec [4,183..5,140] ~ overlap (+14.9%) 6,540 ops/sec [6,119..6,841] → 6,141 ops/sec [6,113..6,157] ~ overlap (-6.1%)
spread to array 14,534 ops/sec [14,076..15,362] → 13,116 ops/sec [12,442..17,599] ~ overlap (-9.8%) 70,889 ops/sec [70,380..71,164] → 72,096 ops/sec [70,663..85,832] ~ overlap (+1.7%)
deduplicate array 22,543 ops/sec [21,088..23,763] → 21,666 ops/sec [20,753..23,325] ~ overlap (-3.9%) 40,267 ops/sec [39,951..40,618] → 40,879 ops/sec [39,779..50,877] ~ overlap (+1.5%)
set 50 entries 2,617 ops/sec [2,380..2,839] → 2,323 ops/sec [2,301..2,358] 🔴 -11.2% 2,938 ops/sec [2,809..2,958] → 2,820 ops/sec [2,777..2,854] ~ overlap (-4.0%)
get lookup (50 entries) 71,616 ops/sec [61,483..84,212] → 72,050 ops/sec [70,004..75,573] ~ overlap (+0.6%) 85,720 ops/sec [84,333..90,681] → 85,082 ops/sec [82,727..86,011] ~ overlap (-0.7%)
has check 90,575 ops/sec [88,091..95,005] → 88,294 ops/sec [88,148..90,128] ~ overlap (-2.5%) 110,757 ops/sec [106,042..112,229] → 107,028 ops/sec [106,061..121,064] ~ overlap (-3.4%)
delete entries 37,179 ops/sec [36,638..37,627] → 39,372 ops/sec [37,013..43,577] ~ overlap (+5.9%) 43,384 ops/sec [42,825..43,713] → 43,483 ops/sec [41,896..45,767] ~ overlap (+0.2%)
forEach iteration 4,057 ops/sec [3,915..4,092] → 4,147 ops/sec [4,035..4,676] ~ overlap (+2.2%) 6,272 ops/sec [6,155..8,551] → 6,775 ops/sec [6,225..7,098] ~ overlap (+8.0%)
keys/values/entries 3,833 ops/sec [3,677..4,832] → 3,612 ops/sec [3,586..3,662] 🔴 -5.8% 11,685 ops/sec [11,263..16,617] → 11,000 ops/sec [10,590..12,569] ~ overlap (-5.9%)
csv.js — Interp: 🔴 1, 12 unch. · avg -1.4% · Bytecode: 🔴 1, 12 unch. · avg +1.7%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
parse simple 3-column CSV 45,250 ops/sec [43,876..51,585] → 49,070 ops/sec [44,147..51,880] ~ overlap (+8.4%) 43,073 ops/sec [42,958..43,466] → 42,877 ops/sec [41,822..71,037] ~ overlap (-0.5%)
parse 10-row CSV 12,943 ops/sec [12,422..18,921] → 14,393 ops/sec [14,253..14,488] ~ overlap (+11.2%) 11,646 ops/sec [11,469..12,929] → 12,772 ops/sec [11,617..15,732] ~ overlap (+9.7%)
parse 100-row CSV 2,108 ops/sec [2,000..2,421] → 2,108 ops/sec [2,078..2,135] ~ overlap (-0.0%) 1,813 ops/sec [1,793..1,958] → 1,795 ops/sec [1,762..2,236] ~ overlap (-1.0%)
parse CSV with quoted fields 74,895 ops/sec [65,369..82,056] → 65,334 ops/sec [62,454..70,764] ~ overlap (-12.8%) 63,062 ops/sec [62,353..66,486] → 63,970 ops/sec [62,794..64,524] ~ overlap (+1.4%)
parse without headers (array of arrays) 6,524 ops/sec [5,690..9,036] → 6,248 ops/sec [5,784..6,375] ~ overlap (-4.2%) 5,580 ops/sec [5,459..5,611] → 5,427 ops/sec [5,401..5,444] 🔴 -2.7%
parse with semicolon delimiter 9,302 ops/sec [9,073..9,936] → 9,903 ops/sec [9,233..10,283] ~ overlap (+6.5%) 8,655 ops/sec [8,606..8,686] → 10,068 ops/sec [8,512..11,497] ~ overlap (+16.3%)
stringify array of objects 62,562 ops/sec [62,147..65,240] → 63,158 ops/sec [61,942..63,911] ~ overlap (+1.0%) 62,306 ops/sec [62,030..65,571] → 63,235 ops/sec [62,156..66,741] ~ overlap (+1.5%)
stringify array of arrays 27,990 ops/sec [25,290..29,208] → 27,352 ops/sec [25,442..29,219] ~ overlap (-2.3%) 23,251 ops/sec [22,267..31,571] → 22,995 ops/sec [18,956..25,784] ~ overlap (-1.1%)
stringify with values needing escaping 56,869 ops/sec [50,870..63,477] → 51,844 ops/sec [48,836..55,857] ~ overlap (-8.8%) 48,155 ops/sec [47,560..59,035] → 48,404 ops/sec [47,764..48,916] ~ overlap (+0.5%)
reviver converts numbers 990 ops/sec [984..998] → 961 ops/sec [944..1,027] ~ overlap (-2.8%) 1,117 ops/sec [1,065..1,156] → 1,046 ops/sec [1,008..1,086] ~ overlap (-6.4%)
reviver filters empty to null 8,034 ops/sec [7,977..8,287] → 7,935 ops/sec [7,689..8,360] ~ overlap (-1.2%) 9,942 ops/sec [9,895..10,019] → 9,980 ops/sec [9,645..10,379] ~ overlap (+0.4%)
parse then stringify 8,677 ops/sec [8,241..9,225] → 7,998 ops/sec [7,792..8,072] 🔴 -7.8% 7,763 ops/sec [7,708..7,811] → 8,147 ops/sec [7,701..9,488] ~ overlap (+4.9%)
stringify then parse 9,295 ops/sec [8,222..9,549] → 8,870 ops/sec [7,921..9,683] ~ overlap (-4.6%) 7,589 ops/sec [7,505..9,057] → 7,529 ops/sec [7,489..7,556] ~ overlap (-0.8%)
destructuring.js — Interp: 🔴 1, 21 unch. · avg -0.1% · Bytecode: 🔴 3, 19 unch. · avg -0.7%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
simple array destructuring 75,680 ops/sec [72,648..77,908] → 73,266 ops/sec [71,586..81,763] ~ overlap (-3.2%) 81,019 ops/sec [80,892..81,163] → 81,224 ops/sec [80,477..99,652] ~ overlap (+0.3%)
with rest element 60,077 ops/sec [59,701..61,807] → 62,184 ops/sec [60,861..65,806] ~ overlap (+3.5%) 64,734 ops/sec [62,945..74,524] → 63,751 ops/sec [61,003..65,708] ~ overlap (-1.5%)
with defaults 73,046 ops/sec [72,081..76,284] → 74,291 ops/sec [72,003..75,829] ~ overlap (+1.7%) 90,772 ops/sec [89,444..117,352] → 85,467 ops/sec [82,635..86,724] 🔴 -5.8%
skip elements 81,406 ops/sec [79,220..82,822] → 80,530 ops/sec [79,859..80,648] ~ overlap (-1.1%) 91,813 ops/sec [91,513..92,112] → 91,824 ops/sec [84,609..93,979] ~ overlap (+0.0%)
nested array destructuring 33,492 ops/sec [33,346..33,836] → 34,864 ops/sec [33,663..37,989] ~ overlap (+4.1%) 31,849 ops/sec [31,269..32,100] → 32,121 ops/sec [28,834..37,795] ~ overlap (+0.9%)
swap variables 99,631 ops/sec [97,893..100,940] → 104,497 ops/sec [98,941..116,573] ~ overlap (+4.9%) 122,403 ops/sec [121,960..122,616] → 114,458 ops/sec [110,626..120,302] 🔴 -6.5%
simple object destructuring 88,944 ops/sec [88,620..91,039] → 87,686 ops/sec [86,500..109,589] ~ overlap (-1.4%) 93,210 ops/sec [90,057..95,611] → 91,995 ops/sec [90,835..94,619] ~ overlap (-1.3%)
with defaults 98,467 ops/sec [97,636..99,520] → 99,977 ops/sec [95,871..110,260] ~ overlap (+1.5%) 134,774 ops/sec [132,482..135,063] → 129,698 ops/sec [123,408..133,801] ~ overlap (-3.8%)
with renaming 98,888 ops/sec [98,210..99,502] → 97,605 ops/sec [96,604..98,962] ~ overlap (-1.3%) 109,346 ops/sec [97,232..123,609] → 98,788 ops/sec [89,603..118,763] ~ overlap (-9.7%)
nested object destructuring 51,846 ops/sec [51,232..51,953] → 51,046 ops/sec [50,443..51,748] ~ overlap (-1.5%) 51,299 ops/sec [50,161..65,903] → 50,925 ops/sec [50,653..51,130] ~ overlap (-0.7%)
rest properties 40,128 ops/sec [39,385..40,373] → 45,233 ops/sec [33,444..50,499] ~ overlap (+12.7%) 44,201 ops/sec [43,421..50,097] → 44,022 ops/sec [40,048..48,827] ~ overlap (-0.4%)
object parameter 28,367 ops/sec [28,073..29,444] → 28,499 ops/sec [27,901..28,811] ~ overlap (+0.5%) 43,077 ops/sec [42,606..48,200] → 43,641 ops/sec [42,572..48,638] ~ overlap (+1.3%)
array parameter 33,828 ops/sec [33,550..33,913] → 33,923 ops/sec [32,743..36,647] ~ overlap (+0.3%) 43,263 ops/sec [40,785..46,747] → 43,264 ops/sec [41,958..49,308] ~ overlap (+0.0%)
mixed destructuring in map 9,223 ops/sec [8,927..9,280] → 9,092 ops/sec [8,936..9,150] ~ overlap (-1.4%) 11,635 ops/sec [11,204..12,249] → 11,617 ops/sec [11,276..13,978] ~ overlap (-0.2%)
forEach with array destructuring 14,866 ops/sec [14,752..17,624] → 14,548 ops/sec [14,298..14,657] 🔴 -2.1% 15,967 ops/sec [15,300..17,557] → 15,922 ops/sec [15,799..16,081] ~ overlap (-0.3%)
map with array destructuring 20,624 ops/sec [16,494..22,345] → 18,785 ops/sec [16,821..25,520] ~ overlap (-8.9%) 15,367 ops/sec [14,761..16,574] → 16,825 ops/sec [15,240..18,207] ~ overlap (+9.5%)
filter with array destructuring 17,998 ops/sec [17,122..21,828] → 17,311 ops/sec [17,036..17,377] ~ overlap (-3.8%) 16,237 ops/sec [16,152..16,434] → 16,165 ops/sec [15,993..16,201] ~ overlap (-0.4%)
reduce with array destructuring 18,170 ops/sec [17,759..18,364] → 18,152 ops/sec [17,788..18,471] ~ overlap (-0.1%) 16,060 ops/sec [15,633..18,437] → 16,583 ops/sec [16,046..16,683] ~ overlap (+3.3%)
map with object destructuring 20,462 ops/sec [19,817..22,402] → 19,934 ops/sec [19,810..20,536] ~ overlap (-2.6%) 23,996 ops/sec [23,238..26,118] → 23,292 ops/sec [23,110..23,371] ~ overlap (-2.9%)
map with nested destructuring 16,951 ops/sec [16,632..17,733] → 16,896 ops/sec [16,286..18,911] ~ overlap (-0.3%) 22,795 ops/sec [22,712..22,868] → 22,391 ops/sec [22,329..23,528] ~ overlap (-1.8%)
map with rest in destructuring 10,244 ops/sec [9,158..12,794] → 9,776 ops/sec [9,228..10,254] ~ overlap (-4.6%) 8,830 ops/sec [8,337..9,275] → 8,280 ops/sec [8,198..8,328] 🔴 -6.2%
map with defaults in destructuring 11,584 ops/sec [11,383..11,875] → 11,586 ops/sec [11,463..11,865] ~ overlap (+0.0%) 16,432 ops/sec [16,191..19,144] → 18,274 ops/sec [18,196..18,317] ~ overlap (+11.2%)
fibonacci.js — Interp: 🔴 2, 6 unch. · avg +0.1% · Bytecode: 🟢 1, 7 unch. · avg -1.2%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
recursive fib(15) 112 ops/sec [109..145] → 103 ops/sec [99..130] ~ overlap (-8.0%) 319 ops/sec [315..319] → 329 ops/sec [321..363] 🟢 +3.3%
recursive fib(20) 10 ops/sec [9..10] → 10 ops/sec [10..11] ~ overlap (+3.8%) 30 ops/sec [29..30] → 29 ops/sec [28..33] ~ overlap (-1.1%)
recursive fib(15) typed 101 ops/sec [100..102] → 102 ops/sec [99..112] ~ overlap (+0.9%) 353 ops/sec [321..405] → 338 ops/sec [322..341] ~ overlap (-4.2%)
recursive fib(20) typed 10 ops/sec [10..10] → 10 ops/sec [10..11] ~ overlap (+3.7%) 31 ops/sec [30..31] → 32 ops/sec [31..33] ~ overlap (+5.2%)
iterative fib(20) via reduce 4,349 ops/sec [4,298..4,457] → 4,426 ops/sec [4,380..4,638] ~ overlap (+1.8%) 6,241 ops/sec [5,808..7,194] → 6,180 ops/sec [6,130..6,848] ~ overlap (-1.0%)
iterator fib(20) 2,584 ops/sec [2,548..2,586] → 2,541 ops/sec [2,512..2,547] 🔴 -1.7% 5,168 ops/sec [4,758..5,314] → 4,898 ops/sec [4,861..4,907] ~ overlap (-5.2%)
iterator fib(20) via Iterator.from + take 2,411 ops/sec [2,389..3,468] → 2,356 ops/sec [2,314..2,380] 🔴 -2.3% 2,842 ops/sec [2,642..3,053] → 2,665 ops/sec [2,586..2,771] ~ overlap (-6.2%)
iterator fib(20) last value via reduce 2,085 ops/sec [2,061..2,400] → 2,142 ops/sec [2,035..2,234] ~ overlap (+2.8%) 2,293 ops/sec [2,207..2,427] → 2,291 ops/sec [2,245..2,708] ~ overlap (-0.1%)
float16array.js — Interp: 🟢 1, 31 unch. · avg -0.2% · Bytecode: 🟢 8, 24 unch. · avg +5.0%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
new Float16Array(0) 100,460 ops/sec [97,225..101,920] → 101,644 ops/sec [101,388..102,537] ~ overlap (+1.2%) 108,202 ops/sec [107,551..108,529] → 108,813 ops/sec [100,186..113,708] ~ overlap (+0.6%)
new Float16Array(100) 95,630 ops/sec [94,528..98,859] → 96,362 ops/sec [94,823..96,746] ~ overlap (+0.8%) 102,862 ops/sec [101,146..112,414] → 103,425 ops/sec [98,638..116,273] ~ overlap (+0.5%)
new Float16Array(1000) 81,362 ops/sec [80,511..81,917] → 87,015 ops/sec [84,698..108,328] 🟢 +6.9% 89,157 ops/sec [88,310..92,886] → 90,380 ops/sec [81,479..95,879] ~ overlap (+1.4%)
Float16Array.from([...100]) 1,718 ops/sec [1,645..1,870] → 1,700 ops/sec [1,615..1,989] ~ overlap (-1.1%) 1,539 ops/sec [1,509..1,581] → 1,639 ops/sec [1,555..1,655] ~ overlap (+6.5%)
Float16Array.of(1.5, 2.5, 3.5, 4.5, 5.5) 86,648 ops/sec [84,113..92,119] → 97,151 ops/sec [84,196..113,183] ~ overlap (+12.1%) 71,651 ops/sec [69,999..72,501] → 82,093 ops/sec [62,530..90,869] ~ overlap (+14.6%)
new Float16Array(float64Array) 28,053 ops/sec [27,811..29,405] → 28,142 ops/sec [27,877..41,036] ~ overlap (+0.3%) 26,748 ops/sec [26,199..31,035] → 29,199 ops/sec [25,891..29,765] ~ overlap (+9.2%)
sequential write 100 elements 1,096 ops/sec [1,088..1,179] → 1,058 ops/sec [1,051..1,106] ~ overlap (-3.5%) 3,189 ops/sec [3,092..3,291] → 3,234 ops/sec [3,141..3,240] ~ overlap (+1.4%)
sequential read 100 elements 1,286 ops/sec [1,174..1,295] → 1,189 ops/sec [1,175..1,493] ~ overlap (-7.5%) 4,221 ops/sec [3,784..4,784] → 3,912 ops/sec [3,794..3,990] ~ overlap (-7.3%)
write special values (NaN, Inf, -0) 49,663 ops/sec [45,689..52,624] → 47,622 ops/sec [47,314..54,169] ~ overlap (-4.1%) 80,163 ops/sec [79,317..93,784] → 81,389 ops/sec [77,262..105,095] ~ overlap (+1.5%)
Float16Array write 1,192 ops/sec [1,129..1,357] → 1,112 ops/sec [1,094..1,130] ~ overlap (-6.7%) 3,328 ops/sec [3,168..5,245] → 3,326 ops/sec [3,297..3,489] ~ overlap (-0.1%)
Float32Array write 1,101 ops/sec [1,067..1,717] → 1,114 ops/sec [1,105..1,231] ~ overlap (+1.2%) 3,332 ops/sec [3,302..3,735] → 3,259 ops/sec [3,147..3,392] ~ overlap (-2.2%)
Float64Array write 1,082 ops/sec [1,076..1,103] → 1,111 ops/sec [1,073..1,208] ~ overlap (+2.7%) 3,219 ops/sec [3,152..3,321] → 3,180 ops/sec [3,145..3,299] ~ overlap (-1.2%)
Float16Array read 1,172 ops/sec [1,156..1,188] → 1,196 ops/sec [1,177..1,213] ~ overlap (+2.0%) 3,472 ops/sec [3,426..3,479] → 3,612 ops/sec [3,608..3,614] 🟢 +4.0%
Float32Array read 1,200 ops/sec [1,182..1,218] → 1,216 ops/sec [1,200..1,219] ~ overlap (+1.3%) 3,758 ops/sec [3,700..4,124] → 3,772 ops/sec [3,699..3,834] ~ overlap (+0.4%)
Float64Array read 1,201 ops/sec [1,186..1,233] → 1,190 ops/sec [1,126..1,217] ~ overlap (-0.9%) 3,800 ops/sec [3,665..4,183] → 3,712 ops/sec [3,657..3,832] ~ overlap (-2.3%)
fill(1.5) 7,263 ops/sec [7,088..7,290] → 7,389 ops/sec [7,148..10,390] ~ overlap (+1.7%) 6,850 ops/sec [6,740..8,133] → 6,685 ops/sec [6,657..8,445] ~ overlap (-2.4%)
slice() 13,337 ops/sec [13,137..14,445] → 13,381 ops/sec [13,231..13,390] ~ overlap (+0.3%) 12,300 ops/sec [12,229..12,362] → 12,204 ops/sec [12,156..12,337] ~ overlap (-0.8%)
map(x => x * 2) 2,286 ops/sec [2,280..2,292] → 2,376 ops/sec [2,220..2,710] ~ overlap (+4.0%) 2,085 ops/sec [2,079..2,125] → 2,135 ops/sec [2,129..2,139] 🟢 +2.4%
filter(x => x > 25) 2,247 ops/sec [2,219..2,275] → 2,250 ops/sec [2,171..2,298] ~ overlap (+0.2%) 2,131 ops/sec [2,019..2,365] → 2,322 ops/sec [2,267..2,630] ~ overlap (+9.0%)
reduce (sum) 2,220 ops/sec [2,173..2,264] → 2,145 ops/sec [2,131..2,249] ~ overlap (-3.4%) 1,956 ops/sec [1,941..1,967] → 2,053 ops/sec [2,027..2,063] 🟢 +4.9%
sort() 20,226 ops/sec [19,884..22,844] → 20,160 ops/sec [19,865..20,320] ~ overlap (-0.3%) 15,816 ops/sec [15,665..16,005] → 19,854 ops/sec [19,502..20,108] 🟢 +25.5%
indexOf() 28,581 ops/sec [27,748..31,017] → 28,997 ops/sec [28,317..32,819] ~ overlap (+1.5%) 23,025 ops/sec [22,742..24,687] → 26,992 ops/sec [26,395..27,263] 🟢 +17.2%
reverse() 31,099 ops/sec [29,658..34,144] → 30,512 ops/sec [28,601..32,984] ~ overlap (-1.9%) 29,100 ops/sec [28,867..29,228] → 29,147 ops/sec [28,914..29,565] ~ overlap (+0.2%)
toReversed() 23,509 ops/sec [23,001..25,930] → 23,521 ops/sec [23,090..23,698] ~ overlap (+0.0%) 17,697 ops/sec [17,412..18,106] → 22,344 ops/sec [22,098..22,462] 🟢 +26.3%
toSorted() 11,885 ops/sec [11,574..11,912] → 11,827 ops/sec [11,788..11,877] ~ overlap (-0.5%) 8,814 ops/sec [8,660..9,215] → 11,077 ops/sec [10,965..13,643] 🟢 +25.7%
create view over existing buffer 110,913 ops/sec [106,365..111,663] → 111,287 ops/sec [107,885..132,633] ~ overlap (+0.3%) 119,463 ops/sec [115,689..122,666] → 117,472 ops/sec [116,865..131,944] ~ overlap (-1.7%)
subarray() 78,007 ops/sec [75,865..93,533] → 77,310 ops/sec [76,367..77,712] ~ overlap (-0.9%) 75,570 ops/sec [75,262..76,904] → 78,405 ops/sec [75,849..80,097] ~ overlap (+3.8%)
set() from array 108,367 ops/sec [105,616..120,514] → 110,001 ops/sec [108,319..126,638] ~ overlap (+1.5%) 127,487 ops/sec [126,431..127,966] → 128,701 ops/sec [128,041..129,998] 🟢 +1.0%
for-of loop 1,734 ops/sec [1,571..1,964] → 1,731 ops/sec [1,587..1,988] ~ overlap (-0.2%) 6,070 ops/sec [5,868..7,020] → 6,527 ops/sec [6,289..6,923] ~ overlap (+7.5%)
spread into array 8,030 ops/sec [6,869..9,877] → 7,278 ops/sec [6,402..10,451] ~ overlap (-9.4%) 23,376 ops/sec [22,271..23,997] → 23,854 ops/sec [22,486..28,001] ~ overlap (+2.0%)
f16round(1.337) 192,888 ops/sec [192,084..199,924] → 196,835 ops/sec [189,458..239,109] ~ overlap (+2.0%) 229,072 ops/sec [222,417..253,859] → 245,882 ops/sec [227,038..267,994] ~ overlap (+7.3%)
f16round over 100 values 1,277 ops/sec [1,197..1,471] → 1,215 ops/sec [1,186..1,242] ~ overlap (-4.9%) 3,009 ops/sec [2,939..3,580] → 3,127 ops/sec [3,117..3,531] ~ overlap (+3.9%)
for-in/for-in.js — Interp: 3 unch. · avg +3.1% · Bytecode: 3 unch. · avg -4.9%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
for...in over 50 own keys 3,203 ops/sec [3,137..3,236] → 3,141 ops/sec [3,085..3,162] ~ overlap (-1.9%) 3,964 ops/sec [3,695..4,355] → 3,850 ops/sec [3,780..4,261] ~ overlap (-2.9%)
for...in over an 8-level chain of 50 shared keys 2,344 ops/sec [2,283..2,520] → 2,297 ops/sec [2,186..2,920] ~ overlap (-2.0%) 3,210 ops/sec [2,829..3,616] → 2,860 ops/sec [2,838..2,885] ~ overlap (-10.9%)
for...in over a 16-level chain of 100 shared keys 923 ops/sec [921..944] → 1,044 ops/sec [927..1,064] ~ overlap (+13.2%) 1,121 ops/sec [1,106..1,474] → 1,110 ops/sec [1,095..1,115] ~ overlap (-1.1%)
for-of.js — Interp: 🔴 1, 6 unch. · avg -1.5% · Bytecode: 🔴 3, 4 unch. · avg -6.6%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
for...of with 10-element array 14,172 ops/sec [13,697..19,524] → 14,074 ops/sec [13,809..14,336] ~ overlap (-0.7%) 77,560 ops/sec [74,516..80,643] → 76,582 ops/sec [73,020..83,144] ~ overlap (-1.3%)
for...of with 100-element array 1,619 ops/sec [1,539..1,662] → 1,642 ops/sec [1,485..1,986] ~ overlap (+1.4%) 9,887 ops/sec [9,657..10,878] → 9,783 ops/sec [9,600..9,956] ~ overlap (-1.1%)
for...of with string (10 chars) 11,393 ops/sec [11,154..11,508] → 11,398 ops/sec [10,604..11,508] ~ overlap (+0.0%) 26,435 ops/sec [25,993..27,773] → 25,910 ops/sec [25,788..25,953] 🔴 -2.0%
for...of with Set (10 elements) 14,462 ops/sec [14,213..17,459] → 14,670 ops/sec [13,665..17,577] ~ overlap (+1.4%) 82,315 ops/sec [77,105..101,739] → 77,180 ops/sec [72,055..86,648] ~ overlap (-6.2%)
for...of with Map entries (10 entries) 8,004 ops/sec [7,649..9,024] → 7,172 ops/sec [7,063..7,195] 🔴 -10.4% 12,680 ops/sec [11,042..12,976] → 10,886 ops/sec [10,699..10,985] 🔴 -14.2%
for...of with destructuring 8,636 ops/sec [7,884..8,851] → 8,237 ops/sec [7,737..10,099] ~ overlap (-4.6%) 15,264 ops/sec [14,764..15,893] → 13,293 ops/sec [13,087..13,320] 🔴 -12.9%
for-await-of with sync array 8,746 ops/sec [8,531..11,253] → 8,940 ops/sec [8,768..9,180] ~ overlap (+2.2%) 1,765 ops/sec [1,708..1,843] → 1,610 ops/sec [1,590..1,842] ~ overlap (-8.8%)
generators.js — Interp: 4 unch. · avg +4.9% · Bytecode: 4 unch. · avg +0.8%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
manual next over object generator 759 ops/sec [747..767] → 869 ops/sec [741..1,064] ~ overlap (+14.5%) 1,012 ops/sec [993..1,028] → 1,030 ops/sec [1,026..1,041] ~ overlap (+1.7%)
for...of over object generator 1,080 ops/sec [1,054..1,113] → 1,186 ops/sec [1,081..1,271] ~ overlap (+9.8%) 1,513 ops/sec [1,437..1,520] → 1,494 ops/sec [1,487..1,507] ~ overlap (-1.2%)
yield delegation 1,109 ops/sec [1,067..1,266] → 1,105 ops/sec [1,024..1,124] ~ overlap (-0.4%) 1,465 ops/sec [1,447..1,506] → 1,498 ops/sec [1,463..1,515] ~ overlap (+2.3%)
class generator method 1,139 ops/sec [1,067..1,468] → 1,090 ops/sec [1,074..1,117] ~ overlap (-4.3%) 1,500 ops/sec [1,439..1,609] → 1,509 ops/sec [1,475..1,524] ~ overlap (+0.6%)
intl.js — Interp: 🔴 1, 5 unch. · avg -2.0% · Bytecode: 🟢 1, 5 unch. · avg +2.4%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
format decimal 30,265 ops/sec [29,081..31,914] → 29,906 ops/sec [29,586..30,361] ~ overlap (-1.2%) 25,747 ops/sec [24,878..26,363] → 25,982 ops/sec [25,604..26,637] ~ overlap (+0.9%)
format currency 23,954 ops/sec [23,106..25,803] → 24,381 ops/sec [23,160..24,792] ~ overlap (+1.8%) 20,139 ops/sec [19,240..22,791] → 20,103 ops/sec [20,053..23,291] ~ overlap (-0.2%)
format UTC date 2,983 ops/sec [2,770..3,169] → 2,712 ops/sec [2,686..2,848] ~ overlap (-9.1%) 2,449 ops/sec [2,319..2,776] → 2,456 ops/sec [2,370..2,611] ~ overlap (+0.3%)
formatRange UTC dates 3,643 ops/sec [3,608..3,707] → 3,571 ops/sec [3,492..3,632] ~ overlap (-2.0%) 3,042 ops/sec [2,959..3,044] → 3,083 ops/sec [3,043..3,181] ~ overlap (+1.3%)
compare numeric strings 113,486 ops/sec [106,739..116,984] → 117,204 ops/sec [107,163..127,730] ~ overlap (+3.3%) 101,673 ops/sec [100,765..102,182] → 116,487 ops/sec [104,246..119,019] 🟢 +14.6%
sort short string list 22,263 ops/sec [21,694..23,473] → 21,179 ops/sec [20,986..21,513] 🔴 -4.9% 20,187 ops/sec [19,430..20,276] → 19,651 ops/sec [19,439..21,139] ~ overlap (-2.7%)
iterators.js — Interp: 🔴 1, 41 unch. · avg -0.5% · Bytecode: 🟢 3, 🔴 2, 37 unch. · avg +0.8%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
Iterator.from({next}).toArray() — 20 elements 3,223 ops/sec [3,004..3,520] → 3,086 ops/sec [3,033..3,227] ~ overlap (-4.2%) 3,870 ops/sec [3,477..3,920] → 4,075 ops/sec [3,936..4,129] 🟢 +5.3%
Iterator.from({next}).toArray() — 50 elements 1,273 ops/sec [1,158..1,381] → 1,298 ops/sec [1,272..1,307] ~ overlap (+2.0%) 1,658 ops/sec [1,525..1,813] → 1,733 ops/sec [1,669..1,959] ~ overlap (+4.5%)
spread pre-wrapped iterator — 20 elements 3,021 ops/sec [2,973..3,125] → 3,122 ops/sec [3,072..3,323] ~ overlap (+3.3%) 5,528 ops/sec [4,997..5,688] → 5,387 ops/sec [5,345..5,434] ~ overlap (-2.5%)
Iterator.from({next}).forEach — 50 elements 955 ops/sec [942..974] → 943 ops/sec [905..1,232] ~ overlap (-1.3%) 1,298 ops/sec [1,285..1,322] → 1,223 ops/sec [1,212..1,341] ~ overlap (-5.8%)
Iterator.from({next}).reduce — 50 elements 1,043 ops/sec [1,025..1,114] → 1,051 ops/sec [1,018..1,210] ~ overlap (+0.8%) 1,306 ops/sec [1,291..1,345] → 1,207 ops/sec [1,194..1,222] 🔴 -7.6%
wrap array iterator 18,478 ops/sec [18,379..18,593] → 18,985 ops/sec [16,830..19,333] ~ overlap (+2.7%) 17,752 ops/sec [17,517..18,166] → 17,255 ops/sec [16,841..17,702] ~ overlap (-2.8%)
wrap plain {next()} object 2,244 ops/sec [2,058..2,496] → 2,100 ops/sec [2,064..2,104] ~ overlap (-6.4%) 2,730 ops/sec [2,627..2,876] → 2,785 ops/sec [2,692..2,880] ~ overlap (+2.0%)
map + toArray (50 elements) 787 ops/sec [762..825] → 787 ops/sec [754..818] ~ overlap (-0.1%) 928 ops/sec [884..978] → 886 ops/sec [866..903] ~ overlap (-4.5%)
filter + toArray (50 elements) 834 ops/sec [806..987] → 824 ops/sec [799..834] ~ overlap (-1.2%) 966 ops/sec [944..1,136] → 1,008 ops/sec [952..1,212] ~ overlap (+4.3%)
take(10) + toArray (50 element source) 4,335 ops/sec [4,306..5,156] → 4,313 ops/sec [4,186..4,571] ~ overlap (-0.5%) 4,862 ops/sec [4,824..4,994] → 4,911 ops/sec [4,871..4,923] ~ overlap (+1.0%)
drop(40) + toArray (50 element source) 1,100 ops/sec [1,093..1,328] → 1,079 ops/sec [1,044..1,136] ~ overlap (-1.9%) 1,440 ops/sec [1,326..1,480] → 1,352 ops/sec [1,323..1,373] ~ overlap (-6.1%)
chained map + filter + take (100 element source) 1,313 ops/sec [1,254..1,316] → 1,310 ops/sec [1,213..1,319] ~ overlap (-0.3%) 1,518 ops/sec [1,429..1,612] → 1,422 ops/sec [1,388..1,541] ~ overlap (-6.3%)
some + every (50 elements) 565 ops/sec [560..602] → 574 ops/sec [556..580] ~ overlap (+1.5%) 711 ops/sec [708..722] → 723 ops/sec [707..802] ~ overlap (+1.7%)
find (50 elements) 1,226 ops/sec [1,204..1,376] → 1,242 ops/sec [1,189..1,314] ~ overlap (+1.3%) 1,538 ops/sec [1,503..1,607] → 1,551 ops/sec [1,528..1,615] ~ overlap (+0.8%)
concat 2 arrays (10 + 10 elements) 7,685 ops/sec [6,991..8,998] → 7,241 ops/sec [6,909..10,629] ~ overlap (-5.8%) 6,434 ops/sec [6,377..8,516] → 6,517 ops/sec [6,458..10,282] ~ overlap (+1.3%)
concat 5 arrays (10 elements each) 3,371 ops/sec [3,003..3,705] → 2,983 ops/sec [2,849..3,141] ~ overlap (-11.5%) 2,765 ops/sec [2,742..2,848] → 2,763 ops/sec [2,738..2,780] ~ overlap (-0.1%)
concat 2 arrays (20 + 20 elements) 3,895 ops/sec [3,668..5,142] → 4,334 ops/sec [4,235..5,037] ~ overlap (+11.3%) 3,562 ops/sec [3,331..3,746] → 3,606 ops/sec [3,394..3,751] ~ overlap (+1.2%)
concat + filter + toArray (20 + 20 elements) 1,655 ops/sec [1,597..2,405] → 1,832 ops/sec [1,643..1,837] ~ overlap (+10.7%) 1,497 ops/sec [1,485..1,502] → 1,603 ops/sec [1,591..1,629] 🟢 +7.1%
concat + map + take (20 + 20 elements, take 10) 4,050 ops/sec [3,936..4,126] → 4,439 ops/sec [3,735..4,739] ~ overlap (+9.6%) 3,619 ops/sec [3,612..3,626] → 3,809 ops/sec [3,791..5,627] 🟢 +5.3%
concat Sets (15 + 15 elements) 5,138 ops/sec [4,985..5,669] → 5,238 ops/sec [5,074..5,611] ~ overlap (+2.0%) 4,742 ops/sec [4,472..7,245] → 4,602 ops/sec [4,429..5,017] ~ overlap (-2.9%)
concat strings (13 + 13 characters) 5,589 ops/sec [5,351..5,736] → 5,692 ops/sec [5,512..6,329] ~ overlap (+1.9%) 5,130 ops/sec [5,063..5,146] → 5,107 ops/sec [5,064..5,275] ~ overlap (-0.5%)
zip 2 arrays (10 + 10 elements) 13,719 ops/sec [12,720..15,271] → 12,390 ops/sec [11,961..15,990] ~ overlap (-9.7%) 12,205 ops/sec [11,895..12,287] → 11,464 ops/sec [11,237..12,034] ~ overlap (-6.1%)
zip 3 arrays (10 elements each) 12,984 ops/sec [11,966..13,826] → 11,619 ops/sec [11,244..13,495] ~ overlap (-10.5%) 11,498 ops/sec [11,310..13,580] → 10,861 ops/sec [10,811..10,917] 🔴 -5.5%
zip 2 arrays (20 + 20 elements) 7,681 ops/sec [7,585..8,052] → 7,437 ops/sec [7,272..7,719] ~ overlap (-3.2%) 7,280 ops/sec [7,216..7,309] → 7,505 ops/sec [6,705..9,637] ~ overlap (+3.1%)
zip 2 arrays (50 + 50 elements) 3,518 ops/sec [3,283..3,721] → 3,713 ops/sec [3,472..4,085] ~ overlap (+5.6%) 3,193 ops/sec [3,152..3,295] → 3,609 ops/sec [3,189..3,970] ~ overlap (+13.0%)
zip shortest mode (20 + 10 elements) 13,276 ops/sec [12,099..15,642] → 12,706 ops/sec [11,955..12,756] ~ overlap (-4.3%) 11,912 ops/sec [11,804..13,414] → 11,933 ops/sec [11,790..13,668] ~ overlap (+0.2%)
zip longest mode (10 + 20 elements) 7,096 ops/sec [7,035..8,934] → 7,089 ops/sec [6,992..7,652] ~ overlap (-0.1%) 6,956 ops/sec [6,661..9,486] → 6,785 ops/sec [6,637..6,914] ~ overlap (-2.5%)
zip strict mode (20 + 20 elements) 7,909 ops/sec [7,375..9,175] → 8,186 ops/sec [7,014..9,247] ~ overlap (+3.5%) 7,987 ops/sec [6,748..8,799] → 7,128 ops/sec [6,827..8,767] ~ overlap (-10.8%)
zip + map + toArray (20 + 20 elements) 2,486 ops/sec [2,390..2,750] → 2,429 ops/sec [2,351..3,249] ~ overlap (-2.3%) 2,198 ops/sec [2,149..2,840] → 2,396 ops/sec [2,154..2,632] ~ overlap (+9.0%)
zip + filter + toArray (20 + 20 elements) 2,597 ops/sec [2,555..2,623] → 2,772 ops/sec [2,523..3,362] ~ overlap (+6.8%) 2,304 ops/sec [2,290..2,346] → 2,583 ops/sec [2,315..2,717] ~ overlap (+12.1%)
zip Sets (15 + 15 elements) 9,770 ops/sec [9,670..10,257] → 10,155 ops/sec [9,437..12,164] ~ overlap (+3.9%) 9,366 ops/sec [9,354..9,418] → 9,495 ops/sec [9,342..9,732] ~ overlap (+1.4%)
zipKeyed 2 keys (10 elements each) 13,395 ops/sec [12,010..16,372] → 14,361 ops/sec [12,209..15,899] ~ overlap (+7.2%) 11,552 ops/sec [11,456..13,081] → 12,223 ops/sec [11,569..12,505] ~ overlap (+5.8%)
zipKeyed 3 keys (20 elements each) 7,007 ops/sec [6,404..8,183] → 6,727 ops/sec [6,490..6,972] ~ overlap (-4.0%) 5,919 ops/sec [5,768..6,243] → 5,760 ops/sec [5,714..5,811] ~ overlap (-2.7%)
zipKeyed longest mode (10 + 20 elements) 7,509 ops/sec [6,923..8,270] → 7,631 ops/sec [7,032..9,332] ~ overlap (+1.6%) 6,225 ops/sec [6,174..6,282] → 6,452 ops/sec [6,164..6,587] ~ overlap (+3.6%)
zipKeyed strict mode (20 + 20 elements) 7,628 ops/sec [6,859..9,117] → 7,207 ops/sec [7,147..7,292] ~ overlap (-5.5%) 6,716 ops/sec [6,480..7,417] → 6,765 ops/sec [6,731..6,864] ~ overlap (+0.7%)
zipKeyed + filter + map (20 elements) 2,251 ops/sec [2,214..2,590] → 2,248 ops/sec [2,134..2,720] ~ overlap (-0.1%) 2,248 ops/sec [2,209..2,365] → 2,318 ops/sec [2,238..2,357] ~ overlap (+3.1%)
array.values().map().filter().toArray() 898 ops/sec [888..1,101] → 880 ops/sec [858..1,113] ~ overlap (-1.9%) 871 ops/sec [869..879] → 921 ops/sec [871..1,214] ~ overlap (+5.8%)
array.values().take(5).toArray() 16,524 ops/sec [15,321..19,480] → 15,258 ops/sec [15,086..15,972] ~ overlap (-7.7%) 15,099 ops/sec [15,023..15,159] → 14,793 ops/sec [14,471..20,085] ~ overlap (-2.0%)
array.values().drop(45).toArray() 3,514 ops/sec [3,320..3,886] → 3,442 ops/sec [3,409..3,605] ~ overlap (-2.1%) 3,042 ops/sec [2,951..3,616] → 3,089 ops/sec [2,995..3,316] ~ overlap (+1.6%)
map.entries() chained helpers 1,282 ops/sec [1,245..1,489] → 1,210 ops/sec [1,200..1,254] ~ overlap (-5.6%) 1,135 ops/sec [1,078..1,410] → 1,174 ops/sec [1,132..1,293] ~ overlap (+3.4%)
set.values() chained helpers 2,210 ops/sec [2,198..2,229] → 2,098 ops/sec [2,085..2,107] 🔴 -5.1% 2,158 ops/sec [2,129..2,186] → 2,244 ops/sec [2,100..2,474] ~ overlap (+4.0%)
string iterator map + toArray 2,253 ops/sec [2,218..2,726] → 2,227 ops/sec [2,156..2,561] ~ overlap (-1.2%) 2,061 ops/sec [2,032..2,134] → 2,097 ops/sec [2,017..2,301] ~ overlap (+1.7%)
json.js — Interp: 🟢 3, 🔴 1, 19 unch. · avg +1.2% · Bytecode: 🔴 4, 19 unch. · avg -1.8%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
parse simple object 66,368 ops/sec [66,093..66,785] → 66,259 ops/sec [65,025..67,194] ~ overlap (-0.2%) 66,253 ops/sec [63,476..73,910] → 61,499 ops/sec [61,133..65,679] ~ overlap (-7.2%)
parse nested object 45,461 ops/sec [44,606..47,981] → 48,147 ops/sec [45,282..51,916] ~ overlap (+5.9%) 43,034 ops/sec [42,280..43,192] → 40,730 ops/sec [40,570..41,356] 🔴 -5.4%
parse array of objects 27,167 ops/sec [26,678..27,361] → 26,963 ops/sec [26,666..30,784] ~ overlap (-0.7%) 25,748 ops/sec [25,405..27,184] → 26,051 ops/sec [25,905..26,138] ~ overlap (+1.2%)
parse large flat object 28,860 ops/sec [28,522..29,299] → 29,930 ops/sec [29,526..31,500] 🟢 +3.7% 28,892 ops/sec [28,170..30,321] → 27,987 ops/sec [27,589..32,643] ~ overlap (-3.1%)
parse mixed types 33,379 ops/sec [32,330..33,585] → 34,966 ops/sec [34,366..36,251] 🟢 +4.8% 34,951 ops/sec [34,084..37,379] → 34,531 ops/sec [34,411..34,571] ~ overlap (-1.2%)
stringify simple object 63,734 ops/sec [61,661..69,475] → 65,229 ops/sec [64,312..72,989] ~ overlap (+2.3%) 57,222 ops/sec [54,511..61,950] → 57,859 ops/sec [55,271..58,280] ~ overlap (+1.1%)
stringify nested object 38,985 ops/sec [38,819..39,076] → 42,157 ops/sec [39,278..46,616] 🟢 +8.1% 31,304 ops/sec [30,248..32,792] → 31,184 ops/sec [30,575..35,502] ~ overlap (-0.4%)
stringify array of objects 18,388 ops/sec [17,866..21,211] → 18,740 ops/sec [17,761..19,597] ~ overlap (+1.9%) 17,342 ops/sec [16,893..21,401] → 16,645 ops/sec [16,554..16,768] 🔴 -4.0%
stringify mixed types 26,967 ops/sec [26,837..29,163] → 27,405 ops/sec [26,856..29,726] ~ overlap (+1.6%) 22,153 ops/sec [21,508..25,954] → 21,782 ops/sec [21,019..21,994] ~ overlap (-1.7%)
reviver doubles numbers 10,704 ops/sec [10,522..10,815] → 11,164 ops/sec [10,612..13,778] ~ overlap (+4.3%) 14,329 ops/sec [14,200..14,787] → 13,811 ops/sec [13,556..14,000] 🔴 -3.6%
reviver filters properties 10,928 ops/sec [10,866..11,115] → 12,623 ops/sec [10,532..13,389] ~ overlap (+15.5%) 13,586 ops/sec [12,622..14,961] → 12,448 ops/sec [12,170..13,797] ~ overlap (-8.4%)
reviver on nested object 13,221 ops/sec [13,172..15,502] → 13,566 ops/sec [12,289..16,235] ~ overlap (+2.6%) 14,381 ops/sec [14,141..14,582] → 14,792 ops/sec [14,552..15,022] ~ overlap (+2.9%)
reviver on array 6,707 ops/sec [6,579..7,035] → 7,441 ops/sec [6,542..8,337] ~ overlap (+10.9%) 8,456 ops/sec [8,422..8,568] → 8,989 ops/sec [8,366..12,055] ~ overlap (+6.3%)
replacer function doubles numbers 12,700 ops/sec [11,934..13,261] → 11,671 ops/sec [11,157..12,238] ~ overlap (-8.1%) 15,066 ops/sec [14,956..15,196] → 14,894 ops/sec [14,735..18,786] ~ overlap (-1.1%)
replacer function excludes properties 17,223 ops/sec [15,808..19,300] → 15,722 ops/sec [14,879..15,794] 🔴 -8.7% 18,849 ops/sec [18,591..19,884] → 18,494 ops/sec [18,125..26,820] ~ overlap (-1.9%)
array replacer (allowlist) 43,390 ops/sec [41,401..49,004] → 42,971 ops/sec [41,450..62,093] ~ overlap (-1.0%) 34,314 ops/sec [33,594..35,661] → 34,450 ops/sec [33,465..54,650] ~ overlap (+0.4%)
stringify with 2-space indent 35,263 ops/sec [34,491..40,358] → 36,419 ops/sec [32,664..41,547] ~ overlap (+3.3%) 28,415 ops/sec [28,247..30,328] → 33,235 ops/sec [29,919..37,199] ~ overlap (+17.0%)
stringify with tab indent 40,234 ops/sec [34,540..43,753] → 35,157 ops/sec [33,113..38,875] ~ overlap (-12.6%) 30,645 ops/sec [30,381..34,513] → 30,229 ops/sec [29,259..31,758] ~ overlap (-1.4%)
stringify deeply nested object with 2-space indent 7,818 ops/sec [7,474..9,437] → 7,712 ops/sec [7,556..8,070] ~ overlap (-1.4%) 7,045 ops/sec [6,701..7,154] → 6,500 ops/sec [6,264..7,033] ~ overlap (-7.7%)
stringify deeply nested array with 2-space indent 10,505 ops/sec [10,415..11,215] → 10,512 ops/sec [10,348..10,984] ~ overlap (+0.1%) 9,702 ops/sec [9,204..11,502] → 9,097 ops/sec [8,802..9,638] ~ overlap (-6.2%)
stringify very deeply nested object with 2-space indent 1,317 ops/sec [1,275..1,543] → 1,281 ops/sec [1,198..1,415] ~ overlap (-2.7%) 1,214 ops/sec [1,192..1,343] → 1,172 ops/sec [1,146..1,193] ~ overlap (-3.5%)
parse then stringify 22,494 ops/sec [21,973..25,642] → 22,330 ops/sec [22,112..22,515] ~ overlap (-0.7%) 22,157 ops/sec [21,177..23,668] → 19,915 ops/sec [19,409..21,086] 🔴 -10.1%
stringify then parse 13,724 ops/sec [13,122..14,377] → 13,682 ops/sec [13,258..13,919] ~ overlap (-0.3%) 12,754 ops/sec [12,362..13,925] → 12,223 ops/sec [11,802..13,726] ~ overlap (-4.2%)
jsx.jsx — Interp: 21 unch. · avg +0.4% · Bytecode: 🔴 2, 19 unch. · avg -1.8%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
simple element 89,088 ops/sec [85,525..94,504] → 86,279 ops/sec [83,354..93,711] ~ overlap (-3.2%) 87,631 ops/sec [86,273..102,086] → 83,692 ops/sec [81,635..84,187] 🔴 -4.5%
self-closing element 87,232 ops/sec [85,869..87,468] → 89,737 ops/sec [87,099..102,000] ~ overlap (+2.9%) 95,702 ops/sec [92,186..106,028] → 93,192 ops/sec [92,194..110,616] ~ overlap (-2.6%)
element with string attribute 73,526 ops/sec [72,047..75,842] → 79,178 ops/sec [72,689..102,899] ~ overlap (+7.7%) 67,356 ops/sec [66,884..78,010] → 70,927 ops/sec [66,602..80,583] ~ overlap (+5.3%)
element with multiple attributes 63,103 ops/sec [62,098..73,507] → 63,952 ops/sec [59,438..75,060] ~ overlap (+1.3%) 54,973 ops/sec [49,790..55,301] → 48,706 ops/sec [48,094..49,813] ~ overlap (-11.4%)
element with expression attribute 65,292 ops/sec [63,472..68,986] → 66,662 ops/sec [66,534..66,788] ~ overlap (+2.1%) 70,545 ops/sec [69,597..73,484] → 69,570 ops/sec [67,882..114,914] ~ overlap (-1.4%)
text child 83,610 ops/sec [82,802..105,429] → 85,071 ops/sec [79,731..95,391] ~ overlap (+1.7%) 86,850 ops/sec [84,431..102,082] → 83,703 ops/sec [82,610..100,693] ~ overlap (-3.6%)
expression child 78,411 ops/sec [75,073..79,055] → 80,121 ops/sec [78,821..85,220] ~ overlap (+2.2%) 81,305 ops/sec [79,257..100,543] → 81,618 ops/sec [79,343..106,896] ~ overlap (+0.4%)
mixed text and expression 73,883 ops/sec [73,107..89,234] → 75,653 ops/sec [74,871..88,022] ~ overlap (+2.4%) 76,348 ops/sec [74,094..80,091] → 81,308 ops/sec [74,598..96,489] ~ overlap (+6.5%)
nested elements (3 levels) 32,899 ops/sec [32,286..33,737] → 33,283 ops/sec [32,649..36,260] ~ overlap (+1.2%) 32,887 ops/sec [32,407..34,940] → 32,861 ops/sec [32,765..35,636] ~ overlap (-0.1%)
sibling children 24,990 ops/sec [24,134..25,279] → 24,895 ops/sec [24,051..24,997] ~ overlap (-0.4%) 23,851 ops/sec [23,552..24,575] → 24,795 ops/sec [23,362..27,456] ~ overlap (+4.0%)
component element 59,856 ops/sec [59,523..85,131] → 71,888 ops/sec [52,310..85,322] ~ overlap (+20.1%) 63,931 ops/sec [62,913..64,935] → 67,998 ops/sec [61,114..79,480] ~ overlap (+6.4%)
component with children 45,440 ops/sec [36,968..52,066] → 40,258 ops/sec [38,407..42,356] ~ overlap (-11.4%) 40,125 ops/sec [36,166..45,000] → 36,510 ops/sec [36,263..43,021] ~ overlap (-9.0%)
dotted component 53,797 ops/sec [51,585..62,926] → 50,855 ops/sec [50,052..57,347] ~ overlap (-5.5%) 47,609 ops/sec [47,429..47,781] → 50,597 ops/sec [47,298..55,457] ~ overlap (+6.3%)
empty fragment 88,753 ops/sec [85,194..94,819] → 91,811 ops/sec [80,866..100,047] ~ overlap (+3.4%) 93,610 ops/sec [92,876..94,042] → 90,788 ops/sec [86,449..96,137] ~ overlap (-3.0%)
fragment with children 25,068 ops/sec [24,495..30,381] → 26,273 ops/sec [24,783..30,441] ~ overlap (+4.8%) 24,313 ops/sec [23,991..24,844] → 24,605 ops/sec [24,376..24,789] ~ overlap (+1.2%)
spread attributes 43,203 ops/sec [42,483..46,811] → 42,231 ops/sec [39,154..51,422] ~ overlap (-2.2%) 37,777 ops/sec [37,627..39,019] → 38,620 ops/sec [37,887..39,080] ~ overlap (+2.2%)
spread with overrides 37,807 ops/sec [37,226..42,661] → 36,564 ops/sec [35,771..37,885] ~ overlap (-3.3%) 33,464 ops/sec [32,779..40,868] → 33,917 ops/sec [33,455..35,149] ~ overlap (+1.4%)
shorthand props 62,244 ops/sec [60,740..67,862] → 62,662 ops/sec [60,103..68,032] ~ overlap (+0.7%) 64,984 ops/sec [64,207..65,996] → 59,849 ops/sec [57,271..74,072] ~ overlap (-7.9%)
nav bar structure 11,972 ops/sec [11,733..12,599] → 12,111 ops/sec [11,600..12,669] ~ overlap (+1.2%) 11,205 ops/sec [10,929..13,395] → 11,557 ops/sec [11,396..12,374] ~ overlap (+3.2%)
card component tree 14,394 ops/sec [13,597..16,241] → 13,992 ops/sec [13,776..16,094] ~ overlap (-2.8%) 16,616 ops/sec [12,364..17,913] → 13,065 ops/sec [11,950..14,107] ~ overlap (-21.4%)
10 list items via Array.from 7,152 ops/sec [5,989..7,736] → 6,121 ops/sec [6,068..6,194] ~ overlap (-14.4%) 5,850 ops/sec [5,466..7,421] → 5,247 ops/sec [5,157..5,445] 🔴 -10.3%
modules.js — Interp: 9 unch. · avg -0.5% · Bytecode: 9 unch. · avg -0.1%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
call imported function 139,900 ops/sec [137,550..142,881] → 141,566 ops/sec [134,432..181,278] ~ overlap (+1.2%) 44,391 ops/sec [43,134..60,940] → 45,108 ops/sec [43,860..49,461] ~ overlap (+1.6%)
call two imported functions 80,972 ops/sec [79,625..106,775] → 80,153 ops/sec [78,561..96,610] ~ overlap (-1.0%) 24,294 ops/sec [22,533..25,393] → 23,237 ops/sec [22,855..23,342] ~ overlap (-4.3%)
read imported constant 373,828 ops/sec [368,502..376,574] → 394,436 ops/sec [361,294..463,565] ~ overlap (+5.5%) 47,221 ops/sec [46,508..47,894] → 47,548 ops/sec [46,775..48,799] ~ overlap (+0.7%)
read imported string 374,373 ops/sec [365,618..403,852] → 377,759 ops/sec [367,433..388,512] ~ overlap (+0.9%) 47,142 ops/sec [46,057..51,065] → 47,157 ops/sec [45,648..52,471] ~ overlap (+0.0%)
read JSON string property 426,792 ops/sec [375,091..672,606] → 383,499 ops/sec [378,146..444,813] ~ overlap (-10.1%) 48,869 ops/sec [46,959..51,620] → 48,800 ops/sec [47,047..52,009] ~ overlap (-0.1%)
read JSON number property 385,016 ops/sec [381,617..449,017] → 383,997 ops/sec [372,684..414,668] ~ overlap (-0.3%) 49,741 ops/sec [46,409..54,308] → 48,629 ops/sec [45,389..71,692] ~ overlap (-2.2%)
read JSON boolean property 391,277 ops/sec [376,086..441,973] → 390,184 ops/sec [384,025..469,307] ~ overlap (-0.3%) 48,063 ops/sec [47,062..48,821] → 49,047 ops/sec [47,675..54,000] ~ overlap (+2.0%)
read JSON array property 383,671 ops/sec [369,320..420,698] → 384,396 ops/sec [371,571..393,690] ~ overlap (+0.2%) 48,238 ops/sec [46,330..49,557] → 51,842 ops/sec [47,289..52,967] ~ overlap (+7.5%)
read multiple JSON properties 220,119 ops/sec [216,994..231,687] → 219,368 ops/sec [215,586..222,135] ~ overlap (-0.3%) 17,679 ops/sec [16,257..19,501] → 16,653 ops/sec [16,612..17,095] ~ overlap (-5.8%)
numbers.js — Interp: 🟢 1, 10 unch. · avg +5.5% · Bytecode: 11 unch. · avg -1.1%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
integer arithmetic 104,449 ops/sec [99,257..121,252] → 116,045 ops/sec [109,041..117,192] ~ overlap (+11.1%) 367,629 ops/sec [364,461..368,435] → 375,369 ops/sec [354,777..378,147] ~ overlap (+2.1%)
floating point arithmetic 123,684 ops/sec [117,093..138,584] → 149,902 ops/sec [128,220..161,898] ~ overlap (+21.2%) 212,854 ops/sec [209,482..253,229] → 227,566 ops/sec [213,341..237,264] ~ overlap (+6.9%)
number coercion 48,167 ops/sec [47,377..49,829] → 48,402 ops/sec [47,423..51,455] ~ overlap (+0.5%) 61,247 ops/sec [60,627..67,096] → 61,329 ops/sec [58,288..63,163] ~ overlap (+0.1%)
toFixed 37,974 ops/sec [36,911..39,748] → 37,651 ops/sec [36,369..40,954] ~ overlap (-0.9%) 44,813 ops/sec [36,917..59,965] → 37,003 ops/sec [35,108..37,172] ~ overlap (-17.4%)
toString 55,208 ops/sec [53,350..63,040] → 53,942 ops/sec [51,841..63,696] ~ overlap (-2.3%) 64,218 ops/sec [62,318..64,770] → 63,308 ops/sec [58,749..65,481] ~ overlap (-1.4%)
valueOf 85,095 ops/sec [78,075..85,917] → 76,815 ops/sec [75,483..119,354] ~ overlap (-9.7%) 92,637 ops/sec [87,512..93,543] → 87,521 ops/sec [85,527..89,554] ~ overlap (-5.5%)
toPrecision 26,615 ops/sec [26,171..27,956] → 26,295 ops/sec [25,933..33,883] ~ overlap (-1.2%) 25,593 ops/sec [24,623..31,341] → 26,629 ops/sec [24,896..30,309] ~ overlap (+4.0%)
Number.isNaN 88,249 ops/sec [84,923..90,511] → 103,645 ops/sec [94,537..122,725] 🟢 +17.4% 100,108 ops/sec [97,790..102,107] → 101,098 ops/sec [99,772..124,399] ~ overlap (+1.0%)
Number.isFinite 85,752 ops/sec [84,679..121,436] → 91,978 ops/sec [84,031..106,188] ~ overlap (+7.3%) 91,205 ops/sec [89,644..91,413] → 90,576 ops/sec [84,460..145,240] ~ overlap (-0.7%)
Number.isInteger 91,139 ops/sec [85,106..112,733] → 103,024 ops/sec [85,328..116,563] ~ overlap (+13.0%) 96,728 ops/sec [93,005..149,359] → 96,905 ops/sec [91,402..112,536] ~ overlap (+0.2%)
Number.parseInt and parseFloat 74,996 ops/sec [73,521..114,760] → 77,706 ops/sec [72,672..103,193] ~ overlap (+3.6%) 73,562 ops/sec [71,529..81,030] → 72,714 ops/sec [70,174..91,442] ~ overlap (-1.2%)
objects.js — Interp: 🔴 1, 6 unch. · avg +2.4% · Bytecode: 7 unch. · avg +4.6%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
create simple object 159,844 ops/sec [153,866..160,225] → 156,226 ops/sec [145,863..159,906] ~ overlap (-2.3%) 129,640 ops/sec [123,081..156,099] → 128,169 ops/sec [124,533..131,051] ~ overlap (-1.1%)
create nested object 88,824 ops/sec [86,723..104,855] → 93,959 ops/sec [85,467..106,420] ~ overlap (+5.8%) 61,423 ops/sec [58,502..78,093] → 69,826 ops/sec [61,856..79,027] ~ overlap (+13.7%)
create 50 objects via Array.from 3,552 ops/sec [3,447..4,073] → 3,946 ops/sec [3,450..4,425] ~ overlap (+11.1%) 2,425 ops/sec [2,411..2,511] → 2,689 ops/sec [2,386..3,186] ~ overlap (+10.9%)
property read 155,319 ops/sec [147,601..189,330] → 148,287 ops/sec [138,715..172,116] ~ overlap (-4.5%) 268,325 ops/sec [264,493..269,456] → 265,257 ops/sec [256,507..334,812] ~ overlap (-1.1%)
Object.keys 95,860 ops/sec [92,622..97,286] → 99,310 ops/sec [89,238..106,902] ~ overlap (+3.6%) 97,335 ops/sec [94,674..97,873] → 100,626 ops/sec [96,743..112,626] ~ overlap (+3.4%)
Object.entries 45,094 ops/sec [43,135..47,582] → 50,761 ops/sec [43,146..52,570] ~ overlap (+12.6%) 43,054 ops/sec [42,573..52,610] → 45,474 ops/sec [43,316..54,090] ~ overlap (+5.6%)
spread operator 61,107 ops/sec [57,783..70,620] → 55,331 ops/sec [53,587..55,420] 🔴 -9.5% 50,766 ops/sec [49,893..51,565] → 51,359 ops/sec [49,553..53,753] ~ overlap (+1.2%)
promises.js — Interp: 12 unch. · avg -3.5% · Bytecode: 12 unch. · avg +2.5%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
Promise.resolve(value) 86,981 ops/sec [76,212..89,483] → 77,070 ops/sec [73,838..81,725] ~ overlap (-11.4%) 75,732 ops/sec [73,726..105,253] → 74,795 ops/sec [72,381..98,064] ~ overlap (-1.2%)
new Promise(resolve => resolve(value)) 66,968 ops/sec [53,147..84,509] → 56,598 ops/sec [54,006..63,323] ~ overlap (-15.5%) 56,956 ops/sec [56,529..57,746] → 64,093 ops/sec [56,170..69,541] ~ overlap (+12.5%)
Promise.reject(reason) 85,571 ops/sec [76,226..111,946] → 90,006 ops/sec [68,563..104,883] ~ overlap (+5.2%) 74,816 ops/sec [74,434..92,124] → 73,621 ops/sec [72,848..78,647] ~ overlap (-1.6%)
resolve + then (1 handler) 26,415 ops/sec [25,495..28,588] → 25,839 ops/sec [24,963..31,864] ~ overlap (-2.2%) 24,747 ops/sec [24,370..25,599] → 25,003 ops/sec [24,485..26,847] ~ overlap (+1.0%)
resolve + then chain (3 deep) 11,361 ops/sec [10,435..13,747] → 11,335 ops/sec [10,719..12,185] ~ overlap (-0.2%) 10,375 ops/sec [10,302..11,013] → 10,528 ops/sec [10,101..10,682] ~ overlap (+1.5%)
resolve + then chain (10 deep) 4,270 ops/sec [3,494..5,017] → 3,535 ops/sec [3,405..4,127] ~ overlap (-17.2%) 3,445 ops/sec [3,285..3,462] → 3,369 ops/sec [3,339..3,458] ~ overlap (-2.2%)
reject + catch + then 14,565 ops/sec [13,928..15,634] → 14,745 ops/sec [14,501..20,668] ~ overlap (+1.2%) 13,677 ops/sec [13,617..14,393] → 14,266 ops/sec [14,185..14,327] ~ overlap (+4.3%)
resolve + finally + then 7,016 ops/sec [6,771..7,405] → 6,959 ops/sec [6,772..8,056] ~ overlap (-0.8%) 6,617 ops/sec [6,553..6,640] → 6,647 ops/sec [6,600..6,729] ~ overlap (+0.4%)
Promise.all (5 resolved) 5,040 ops/sec [4,801..5,494] → 4,992 ops/sec [4,863..5,211] ~ overlap (-1.0%) 4,632 ops/sec [4,529..4,687] → 4,808 ops/sec [4,454..5,346] ~ overlap (+3.8%)
Promise.race (5 resolved) 5,616 ops/sec [4,910..5,737] → 5,652 ops/sec [5,468..5,712] ~ overlap (+0.6%) 5,138 ops/sec [5,095..5,259] → 5,187 ops/sec [4,742..6,077] ~ overlap (+1.0%)
Promise.allSettled (5 mixed) 4,085 ops/sec [4,009..4,467] → 4,143 ops/sec [4,104..4,174] ~ overlap (+1.4%) 3,769 ops/sec [3,729..3,925] → 4,153 ops/sec [3,784..4,976] ~ overlap (+10.2%)
Promise.any (5 mixed) 5,716 ops/sec [4,959..6,760] → 5,597 ops/sec [4,925..6,701] ~ overlap (-2.1%) 4,562 ops/sec [4,541..5,952] → 4,570 ops/sec [4,411..6,207] ~ overlap (+0.2%)
property-access.js — Interp: 5 unch. · avg -3.7% · Bytecode: 5 unch. · avg -5.2%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
class instance fields across 1000 instances 161 ops/sec [150..167] → 147 ops/sec [143..183] ~ overlap (-9.0%) 701 ops/sec [661..1,166] → 653 ops/sec [642..701] ~ overlap (-6.8%)
object literal fields across 1000 literals 173 ops/sec [155..183] → 164 ops/sec [150..192] ~ overlap (-4.9%) 751 ops/sec [657..1,039] → 670 ops/sec [654..786] ~ overlap (-10.8%)
mixed-shape literals across 1000 literals 156 ops/sec [151..162] → 152 ops/sec [152..153] ~ overlap (-2.5%) 526 ops/sec [508..573] → 517 ops/sec [506..849] ~ overlap (-1.8%)
own-class method across 1000 instances 92 ops/sec [91..105] → 96 ops/sec [94..99] ~ overlap (+3.9%) 368 ops/sec [324..436] → 338 ops/sec [317..354] ~ overlap (-8.1%)
inherited method across 1000 instances 107 ops/sec [99..117] → 101 ops/sec [98..105] ~ overlap (-5.9%) 380 ops/sec [370..443] → 386 ops/sec [366..406] ~ overlap (+1.4%)
regexp.js — Interp: 🟢 1, 10 unch. · avg -2.4% · Bytecode: 🔴 2, 9 unch. · avg -1.5%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
regex literal creation 8,007 ops/sec [7,898..10,355] → 8,070 ops/sec [8,041..9,027] ~ overlap (+0.8%) 186,248 ops/sec [185,433..187,949] → 180,299 ops/sec [178,507..184,618] 🔴 -3.2%
new RegExp(pattern, flags) 7,995 ops/sec [7,681..9,085] → 7,955 ops/sec [7,740..8,350] ~ overlap (-0.5%) 7,287 ops/sec [7,258..7,301] → 7,159 ops/sec [5,649..8,172] ~ overlap (-1.8%)
RegExp(existingRegex) returns the same regex 223,324 ops/sec [189,656..293,693] → 194,659 ops/sec [192,643..197,052] ~ overlap (-12.8%) 304,844 ops/sec [267,190..322,816] → 263,923 ops/sec [263,093..264,122] 🔴 -13.4%
test() on a global regex 61,635 ops/sec [59,108..83,068] → 61,056 ops/sec [59,606..67,410] ~ overlap (-0.9%) 72,876 ops/sec [70,622..76,500] → 76,410 ops/sec [69,650..89,237] ~ overlap (+4.9%)
exec() with capture groups 14,653 ops/sec [13,769..18,442] → 14,317 ops/sec [13,897..14,399] ~ overlap (-2.3%) 16,725 ops/sec [16,472..17,718] → 16,708 ops/sec [16,200..18,552] ~ overlap (-0.1%)
toString() 170,964 ops/sec [169,634..171,666] → 166,393 ops/sec [162,993..178,421] ~ overlap (-2.7%) 220,696 ops/sec [217,103..222,704] → 222,066 ops/sec [216,826..227,187] ~ overlap (+0.6%)
match() with global regex 26,617 ops/sec [23,775..27,521] → 23,180 ops/sec [22,332..24,183] ~ overlap (-12.9%) 22,474 ops/sec [21,830..25,846] → 24,046 ops/sec [22,138..32,892] ~ overlap (+7.0%)
matchAll() with capture groups 10,936 ops/sec [10,838..12,062] → 10,756 ops/sec [10,533..14,369] ~ overlap (-1.6%) 14,748 ops/sec [13,829..16,498] → 13,932 ops/sec [13,617..21,035] ~ overlap (-5.5%)
replace() with global regex 20,679 ops/sec [19,963..23,289] → 21,031 ops/sec [20,292..23,772] ~ overlap (+1.7%) 20,018 ops/sec [19,703..20,083] → 19,595 ops/sec [18,986..20,279] ~ overlap (-2.1%)
search() with regex 50,448 ops/sec [43,686..59,812] → 48,239 ops/sec [45,308..54,394] ~ overlap (-4.4%) 47,033 ops/sec [46,728..47,343] → 46,422 ops/sec [46,020..49,516] ~ overlap (-1.3%)
split() with regex separator 8,283 ops/sec [8,222..8,303] → 9,088 ops/sec [8,399..11,136] 🟢 +9.7% 7,689 ops/sec [7,455..7,755] → 7,593 ops/sec [7,263..8,927] ~ overlap (-1.3%)
strings.js — Interp: 19 unch. · avg -3.1% · Bytecode: 🔴 1, 18 unch. · avg -0.5%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
string concatenation 140,055 ops/sec [126,737..151,595] → 125,445 ops/sec [123,945..163,384] ~ overlap (-10.4%) 513,583 ops/sec [498,712..522,968] → 489,089 ops/sec [488,524..491,134] 🔴 -4.8%
template literal 248,020 ops/sec [212,888..301,644] → 234,885 ops/sec [217,719..263,937] ~ overlap (-5.3%) 396,090 ops/sec [372,247..398,193] → 377,926 ops/sec [365,314..406,982] ~ overlap (-4.6%)
string repeat 164,821 ops/sec [145,615..176,302] → 150,847 ops/sec [145,064..187,274] ~ overlap (-8.5%) 158,833 ops/sec [158,404..160,125] → 159,437 ops/sec [155,062..203,184] ~ overlap (+0.4%)
split and join 54,906 ops/sec [53,641..59,087] → 55,980 ops/sec [52,585..61,842] ~ overlap (+2.0%) 57,095 ops/sec [55,216..65,876] → 54,756 ops/sec [54,224..70,183] ~ overlap (-4.1%)
indexOf and includes 61,753 ops/sec [57,418..69,097] → 58,686 ops/sec [57,323..61,417] ~ overlap (-5.0%) 61,693 ops/sec [57,274..67,588] → 57,964 ops/sec [56,150..66,889] ~ overlap (-6.0%)
toUpperCase and toLowerCase 75,756 ops/sec [70,054..77,897] → 74,880 ops/sec [71,881..80,337] ~ overlap (-1.2%) 78,215 ops/sec [77,327..84,699] → 76,843 ops/sec [76,103..89,639] ~ overlap (-1.8%)
slice and substring 54,058 ops/sec [53,836..54,599] → 52,873 ops/sec [52,408..74,424] ~ overlap (-2.2%) 61,593 ops/sec [61,503..62,145] → 62,580 ops/sec [60,339..78,901] ~ overlap (+1.6%)
trim operations 64,502 ops/sec [61,327..66,568] → 63,133 ops/sec [62,247..64,315] ~ overlap (-2.1%) 70,511 ops/sec [67,944..71,029] → 69,820 ops/sec [68,650..91,114] ~ overlap (-1.0%)
replace and replaceAll 70,980 ops/sec [62,867..76,270] → 63,179 ops/sec [61,344..71,605] ~ overlap (-11.0%) 62,866 ops/sec [61,862..63,890] → 63,182 ops/sec [62,743..63,254] ~ overlap (+0.5%)
startsWith and endsWith 45,084 ops/sec [44,439..51,343] → 44,870 ops/sec [43,989..48,661] ~ overlap (-0.5%) 46,769 ops/sec [46,442..46,819] → 50,474 ops/sec [45,848..55,642] ~ overlap (+7.9%)
padStart and padEnd 75,310 ops/sec [69,910..87,370] → 71,909 ops/sec [69,924..85,829] ~ overlap (-4.5%) 75,147 ops/sec [73,349..75,406] → 75,286 ops/sec [74,848..85,830] ~ overlap (+0.2%)
identity tag, no substitutions 116,499 ops/sec [114,288..125,563] → 114,498 ops/sec [112,539..118,218] ~ overlap (-1.7%) 158,685 ops/sec [156,996..162,196] → 161,939 ops/sec [156,459..177,698] ~ overlap (+2.1%)
tag with 1 substitution 27,937 ops/sec [27,710..28,273] → 27,392 ops/sec [27,065..28,203] ~ overlap (-2.0%) 31,723 ops/sec [30,925..38,761] → 31,904 ops/sec [31,697..40,965] ~ overlap (+0.6%)
tag with 3 substitutions 15,840 ops/sec [15,567..15,854] → 15,477 ops/sec [15,121..15,795] ~ overlap (-2.3%) 18,552 ops/sec [18,313..18,848] → 19,032 ops/sec [18,647..19,311] ~ overlap (+2.6%)
tag with 6 substitutions 9,371 ops/sec [9,100..10,271] → 9,260 ops/sec [9,251..9,684] ~ overlap (-1.2%) 11,574 ops/sec [11,202..11,826] → 11,787 ops/sec [11,685..11,990] ~ overlap (+1.8%)
String.raw, no substitutions 92,313 ops/sec [91,789..92,536] → 90,885 ops/sec [88,534..97,000] ~ overlap (-1.5%) 86,438 ops/sec [86,169..88,466] → 86,928 ops/sec [86,670..87,926] ~ overlap (+0.6%)
String.raw, 2 substitutions 76,445 ops/sec [74,815..78,709] → 75,260 ops/sec [74,319..84,770] ~ overlap (-1.5%) 70,708 ops/sec [68,624..76,020] → 69,626 ops/sec [67,473..74,405] ~ overlap (-1.5%)
tag accessing .raw array 44,404 ops/sec [42,718..45,003] → 44,420 ops/sec [44,028..45,054] ~ overlap (+0.0%) 44,971 ops/sec [44,237..45,230] → 44,719 ops/sec [44,563..44,906] ~ overlap (-0.6%)
method as tag (this binding) 18,493 ops/sec [18,112..18,603] → 18,612 ops/sec [18,362..19,314] ~ overlap (+0.6%) 22,881 ops/sec [22,149..23,978] → 22,080 ops/sec [21,885..22,465] ~ overlap (-3.5%)
temporal.js — Interp: 6 unch. · avg +1.0% · Bytecode: 🔴 2, 4 unch. · avg -3.2%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
PlainDate.add({ months: 1 }) 46,898 ops/sec [46,018..55,363] → 47,853 ops/sec [47,048..49,507] ~ overlap (+2.0%) 43,770 ops/sec [43,353..54,068] → 43,318 ops/sec [42,214..44,930] ~ overlap (-1.0%)
PlainDate.until(..., { largestUnit: 'months' }) 60,583 ops/sec [56,450..81,310] → 60,480 ops/sec [57,564..71,601] ~ overlap (-0.2%) 53,835 ops/sec [53,668..54,096] → 53,581 ops/sec [52,468..59,171] ~ overlap (-0.5%)
Duration.total days relative to PlainDate 51,006 ops/sec [49,807..52,806] → 52,336 ops/sec [51,712..54,883] ~ overlap (+2.6%) 46,262 ops/sec [45,286..46,659] → 44,339 ops/sec [44,147..44,683] 🔴 -4.2%
Duration.round to hours 37,282 ops/sec [36,105..42,856] → 39,683 ops/sec [36,871..44,691] ~ overlap (+6.4%) 33,546 ops/sec [32,729..39,511] → 32,778 ops/sec [31,847..40,932] ~ overlap (-2.3%)
ZonedDateTime.from named time zone 12,162 ops/sec [11,821..12,496] → 11,966 ops/sec [11,738..12,045] ~ overlap (-1.6%) 11,381 ops/sec [10,171..12,666] → 10,285 ops/sec [9,974..12,417] ~ overlap (-9.6%)
ZonedDateTime.since across DST 12,269 ops/sec [11,967..13,786] → 11,855 ops/sec [11,471..15,228] ~ overlap (-3.4%) 10,153 ops/sec [10,045..11,363] → 9,980 ops/sec [9,923..10,027] 🔴 -1.7%
tsv.js — Interp: 🔴 1, 8 unch. · avg +0.3% · Bytecode: 🔴 1, 8 unch. · avg -0.3%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
parse simple 3-column TSV 45,338 ops/sec [45,134..45,449] → 43,687 ops/sec [42,969..47,523] ~ overlap (-3.6%) 42,988 ops/sec [42,412..43,204] → 45,073 ops/sec [42,499..46,937] ~ overlap (+4.9%)
parse 10-row TSV 12,751 ops/sec [12,288..14,757] → 12,460 ops/sec [12,278..14,054] ~ overlap (-2.3%) 11,535 ops/sec [11,390..11,589] → 11,554 ops/sec [11,510..13,759] ~ overlap (+0.2%)
parse 100-row TSV 1,975 ops/sec [1,960..2,012] → 1,997 ops/sec [1,981..2,382] ~ overlap (+1.1%) 1,850 ops/sec [1,843..2,121] → 1,871 ops/sec [1,796..2,321] ~ overlap (+1.1%)
parse TSV with backslash-escaped fields 10,151 ops/sec [9,520..11,218] → 10,580 ops/sec [9,012..11,200] ~ overlap (+4.2%) 8,842 ops/sec [8,667..8,986] → 8,559 ops/sec [8,528..8,584] 🔴 -3.2%
parse without headers (array of arrays) 6,208 ops/sec [6,057..7,454] → 6,982 ops/sec [5,786..7,472] ~ overlap (+12.5%) 6,417 ops/sec [5,611..6,505] → 5,601 ops/sec [5,577..5,681] ~ overlap (-12.7%)
stringify array of objects 41,518 ops/sec [39,535..44,442] → 39,764 ops/sec [39,407..54,049] ~ overlap (-4.2%) 38,714 ops/sec [37,908..41,201] → 37,734 ops/sec [36,877..38,171] ~ overlap (-2.5%)
stringify array of arrays 12,429 ops/sec [12,165..12,614] → 12,438 ops/sec [12,068..12,651] ~ overlap (+0.1%) 11,233 ops/sec [11,087..11,273] → 11,249 ops/sec [11,153..12,690] ~ overlap (+0.1%)
stringify with values needing escaping 33,036 ops/sec [32,366..36,422] → 31,977 ops/sec [31,300..42,498] ~ overlap (-3.2%) 31,516 ops/sec [30,128..34,305] → 33,703 ops/sec [30,605..39,791] ~ overlap (+6.9%)
parse then stringify 7,199 ops/sec [7,111..7,391] → 7,057 ops/sec [6,852..7,069] 🔴 -2.0% 6,530 ops/sec [6,353..6,631] → 6,670 ops/sec [6,505..8,892] ~ overlap (+2.1%)
typed-arrays.js — Interp: 🟢 2, 🔴 6, 14 unch. · avg -5.7% · Bytecode: 🔴 11, 11 unch. · avg -12.2%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
new Int32Array(0) 101,335 ops/sec [98,381..121,828] → 105,784 ops/sec [98,170..110,905] ~ overlap (+4.4%) 107,382 ops/sec [104,814..134,621] → 123,300 ops/sec [105,223..129,800] ~ overlap (+14.8%)
new Int32Array(100) 101,458 ops/sec [92,743..120,556] → 97,018 ops/sec [92,813..104,937] ~ overlap (-4.4%) 101,876 ops/sec [98,302..102,788] → 102,785 ops/sec [101,763..122,906] ~ overlap (+0.9%)
new Int32Array(1000) 77,287 ops/sec [73,012..100,884] → 73,949 ops/sec [68,404..88,311] ~ overlap (-4.3%) 79,099 ops/sec [78,688..79,943] → 78,113 ops/sec [77,818..78,801] ~ overlap (-1.2%)
new Float64Array(100) 91,692 ops/sec [90,703..93,680] → 94,851 ops/sec [92,882..95,544] ~ overlap (+3.4%) 101,183 ops/sec [97,528..114,946] → 98,571 ops/sec [97,871..103,915] ~ overlap (-2.6%)
Int32Array.from([...]) 1,624 ops/sec [1,605..1,989] → 1,582 ops/sec [1,545..1,660] ~ overlap (-2.6%) 1,457 ops/sec [1,439..1,605] → 1,643 ops/sec [1,466..1,918] ~ overlap (+12.8%)
Int32Array.of(1, 2, 3, 4, 5) 76,972 ops/sec [76,136..77,269] → 77,314 ops/sec [76,164..87,932] ~ overlap (+0.4%) 77,493 ops/sec [76,796..82,808] → 79,110 ops/sec [77,074..80,099] ~ overlap (+2.1%)
sequential write 100 elements 1,126 ops/sec [1,095..1,130] → 1,115 ops/sec [1,108..1,123] ~ overlap (-1.0%) 3,704 ops/sec [3,439..5,176] → 3,717 ops/sec [3,656..4,025] ~ overlap (+0.4%)
sequential read 100 elements 1,205 ops/sec [1,173..1,360] → 1,211 ops/sec [1,207..1,238] ~ overlap (+0.5%) 4,160 ops/sec [4,072..4,191] → 4,109 ops/sec [4,095..4,243] ~ overlap (-1.2%)
Float64Array write 100 elements 1,067 ops/sec [1,044..1,070] → 1,117 ops/sec [1,087..1,118] 🟢 +4.7% 3,234 ops/sec [3,216..3,260] → 3,145 ops/sec [3,120..3,165] 🔴 -2.8%
fill(42) 2,372 ops/sec [2,318..2,436] → 2,367 ops/sec [2,353..2,551] ~ overlap (-0.2%) 2,172 ops/sec [2,099..2,338] → 2,090 ops/sec [2,078..2,098] 🔴 -3.8%
slice() 9,871 ops/sec [9,609..9,918] → 9,826 ops/sec [9,772..9,877] ~ overlap (-0.5%) 9,476 ops/sec [8,834..10,388] → 8,602 ops/sec [8,545..8,787] 🔴 -9.2%
map(x => x * 2) 2,226 ops/sec [2,178..2,319] → 2,202 ops/sec [2,183..2,220] ~ overlap (-1.1%) 2,167 ops/sec [2,161..2,176] → 2,113 ops/sec [2,109..2,119] 🔴 -2.5%
filter(x => x > 50) 3,801 ops/sec [3,776..3,809] → 2,334 ops/sec [2,287..3,051] 🔴 -38.6% 2,294 ops/sec [2,281..2,328] → 2,278 ops/sec [2,255..2,284] ~ overlap (-0.7%)
reduce (sum) 3,923 ops/sec [3,919..3,945] → 2,298 ops/sec [2,257..2,300] 🔴 -41.4% 2,195 ops/sec [2,168..2,211] → 2,161 ops/sec [2,149..2,181] ~ overlap (-1.5%)
sort() 23,675 ops/sec [23,567..23,788] → 14,740 ops/sec [14,581..15,146] 🔴 -37.7% 19,193 ops/sec [14,026..24,406] → 13,509 ops/sec [13,338..13,655] 🔴 -29.6%
indexOf() 51,846 ops/sec [51,515..52,256] → 33,252 ops/sec [32,353..34,901] 🔴 -35.9% 30,910 ops/sec [30,455..35,625] → 29,705 ops/sec [29,351..30,527] ~ overlap (-3.9%)
reverse() 26,201 ops/sec [16,854..26,320] → 16,977 ops/sec [16,776..17,647] ~ overlap (-35.2%) 27,385 ops/sec [16,616..27,552] → 15,062 ops/sec [15,027..15,222] 🔴 -45.0%
create view over existing buffer 112,717 ops/sec [111,805..114,404] → 129,504 ops/sec [110,396..130,348] ~ overlap (+14.9%) 193,907 ops/sec [193,310..194,970] → 119,529 ops/sec [118,940..120,073] 🔴 -38.4%
subarray() 78,069 ops/sec [76,067..78,679] → 120,470 ops/sec [119,559..121,396] 🟢 +54.3% 123,675 ops/sec [122,885..124,075] → 76,542 ops/sec [73,791..109,411] 🔴 -38.1%
set() from array 136,092 ops/sec [133,036..136,623] → 131,506 ops/sec [130,806..132,781] 🔴 -3.4% 152,436 ops/sec [152,005..153,240] → 97,659 ops/sec [85,301..107,311] 🔴 -35.9%
for-of loop 2,666 ops/sec [2,659..2,691] → 2,682 ops/sec [2,655..2,700] ~ overlap (+0.6%) 13,402 ops/sec [13,312..13,448] → 7,639 ops/sec [7,357..8,301] 🔴 -43.0%
spread into array 10,827 ops/sec [10,789..10,890] → 10,639 ops/sec [10,583..10,691] 🔴 -1.7% 39,705 ops/sec [39,238..39,822] → 23,770 ops/sec [23,550..24,347] 🔴 -40.1%
uint8array-encoding.js — Interp: 🟢 5, 🔴 2, 11 unch. · avg +14.7% · Bytecode: 🟢 3, 🔴 2, 13 unch. · avg +10.8%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
short (5 bytes) 155,068 ops/sec [152,599..155,546] → 156,458 ops/sec [152,482..190,248] ~ overlap (+0.9%) 182,145 ops/sec [181,407..182,898] → 192,126 ops/sec [178,299..209,907] ~ overlap (+5.5%)
medium (450 bytes) 111,648 ops/sec [108,181..135,988] → 116,187 ops/sec [107,334..121,485] ~ overlap (+4.1%) 116,820 ops/sec [115,590..119,177] → 117,064 ops/sec [115,871..121,246] ~ overlap (+0.2%)
large (4096 bytes) 30,736 ops/sec [29,959..31,673] → 31,751 ops/sec [30,551..32,857] ~ overlap (+3.3%) 30,496 ops/sec [29,993..30,744] → 31,180 ops/sec [29,369..31,412] ~ overlap (+2.2%)
base64url alphabet 83,542 ops/sec [82,307..86,804] → 82,982 ops/sec [82,027..83,281] ~ overlap (-0.7%) 76,427 ops/sec [75,691..85,836] → 77,307 ops/sec [77,182..77,365] ~ overlap (+1.2%)
omitPadding 108,230 ops/sec [106,686..110,067] → 109,043 ops/sec [108,933..109,181] ~ overlap (+0.8%) 106,160 ops/sec [103,918..108,495] → 108,068 ops/sec [107,019..119,030] ~ overlap (+1.8%)
short (8 chars) 121,794 ops/sec [121,466..123,473] → 123,414 ops/sec [119,698..123,997] ~ overlap (+1.3%) 132,356 ops/sec [128,794..133,166] → 132,235 ops/sec [131,782..132,721] ~ overlap (-0.1%)
medium (600 chars) 64,775 ops/sec [63,391..66,937] → 66,011 ops/sec [65,837..66,059] ~ overlap (+1.9%) 68,744 ops/sec [67,912..70,620] → 67,536 ops/sec [67,040..67,610] 🔴 -1.8%
large (5464 chars) 14,080 ops/sec [13,457..14,543] → 14,205 ops/sec [13,465..15,064] ~ overlap (+0.9%) 14,045 ops/sec [13,996..14,497] → 13,899 ops/sec [13,173..16,730] ~ overlap (-1.0%)
short (5 bytes) 160,114 ops/sec [156,301..160,748] → 154,334 ops/sec [149,192..165,437] ~ overlap (-3.6%) 334,335 ops/sec [331,619..336,597] → 322,615 ops/sec [319,405..324,241] 🔴 -3.5%
medium (450 bytes) 99,319 ops/sec [97,672..102,040] → 94,929 ops/sec [93,597..96,062] 🔴 -4.4% 180,690 ops/sec [108,781..181,084] → 173,836 ops/sec [173,638..173,982] ~ overlap (-3.8%)
large (4096 bytes) 24,900 ops/sec [24,558..24,972] → 22,618 ops/sec [22,160..23,430] 🔴 -9.2% 23,797 ops/sec [23,300..23,856] → 37,042 ops/sec [23,945..38,215] 🟢 +55.7%
short (10 chars) 134,020 ops/sec [127,438..144,791] → 128,871 ops/sec [125,495..182,567] ~ overlap (-3.8%) 218,680 ops/sec [143,815..232,606] → 231,961 ops/sec [230,356..233,597] ~ overlap (+6.1%)
medium (900 chars) 91,308 ops/sec [90,409..91,512] → 148,765 ops/sec [148,346..150,705] 🟢 +62.9% 97,546 ops/sec [97,136..98,786] → 169,956 ops/sec [169,205..170,803] 🟢 +74.2%
large (8192 chars) 27,849 ops/sec [25,685..32,468] → 45,722 ops/sec [44,532..46,259] 🟢 +64.2% 26,302 ops/sec [25,620..27,287] → 51,021 ops/sec [50,577..52,045] 🟢 +94.0%
setFromBase64 (450 bytes) 59,440 ops/sec [58,629..60,382] → 92,475 ops/sec [91,582..93,321] 🟢 +55.6% 97,769 ops/sec [59,380..98,655] → 96,622 ops/sec [95,492..97,771] ~ overlap (-1.2%)
setFromHex (450 bytes) 25,387 ops/sec [23,373..26,175] → 35,671 ops/sec [35,407..36,308] 🟢 +40.5% 36,512 ops/sec [36,304..36,972] → 36,552 ops/sec [22,002..36,811] ~ overlap (+0.1%)
toBase64 → fromBase64 (450 bytes) 72,357 ops/sec [46,566..72,899] → 72,915 ops/sec [72,129..73,877] ~ overlap (+0.8%) 75,237 ops/sec [74,783..75,537] → 47,980 ops/sec [47,770..77,802] ~ overlap (-36.2%)
toHex → fromHex (450 bytes) 56,653 ops/sec [54,304..57,358] → 84,447 ops/sec [83,709..85,231] 🟢 +49.1% 95,348 ops/sec [94,909..95,739] → 95,774 ops/sec [95,236..96,507] ~ overlap (+0.4%)
weak-collections.js — Interp: 🔴 4, 11 unch. · avg -7.7% · Bytecode: 🟢 3, 🔴 4, 8 unch. · avg +1.9%
Benchmark Interpreted (main → PR) Δ Bytecode (main → PR) Δ
constructor from 50 entries 10,557 ops/sec [10,405..10,881] → 11,038 ops/sec [10,804..11,445] ~ overlap (+4.6%) 10,544 ops/sec [9,326..10,580] → 9,657 ops/sec [9,447..10,305] ~ overlap (-8.4%)
set 50 object keys 3,179 ops/sec [3,133..3,184] → 3,179 ops/sec [3,164..3,192] ~ overlap (-0.0%) 3,751 ops/sec [3,664..3,793] → 3,744 ops/sec [3,713..3,788] ~ overlap (-0.2%)
get lookups (50 entries) 47,689 ops/sec [47,544..48,238] → 47,770 ops/sec [46,536..48,137] ~ overlap (+0.2%) 78,574 ops/sec [75,725..82,764] → 133,043 ops/sec [132,807..133,265] 🟢 +69.3%
has checks (50 entries) 61,770 ops/sec [61,221..62,817] → 60,664 ops/sec [60,445..62,859] ~ overlap (-1.8%) 110,979 ops/sec [98,732..121,774] → 100,206 ops/sec [99,267..101,504] ~ overlap (-9.7%)
delete entries 2,954 ops/sec [2,921..3,020] → 2,913 ops/sec [2,805..2,982] ~ overlap (-1.4%) 3,680 ops/sec [3,605..5,007] → 3,759 ops/sec [3,741..3,774] ~ overlap (+2.2%)
non-registered symbol keys 7,323 ops/sec [7,211..7,351] → 7,126 ops/sec [7,114..7,165] 🔴 -2.7% 8,847 ops/sec [8,718..9,771] → 8,935 ops/sec [8,867..11,079] ~ overlap (+1.0%)
getOrInsert 3,086 ops/sec [3,042..3,115] → 3,045 ops/sec [3,030..3,117] ~ overlap (-1.3%) 3,478 ops/sec [3,405..3,486] → 3,732 ops/sec [3,518..5,761] 🟢 +7.3%
getOrInsertComputed 1,792 ops/sec [1,762..1,804] → 1,798 ops/sec [1,783..1,828] ~ overlap (+0.3%) 2,968 ops/sec [2,946..2,981] → 1,766 ops/sec [1,758..1,795] 🔴 -40.5%
forced gc live-key retention 72 ops/sec [70..74] → 84 ops/sec [59..104] ~ overlap (+16.3%) 126 ops/sec [125..126] → 113 ops/sec [91..127] ~ overlap (-10.3%)
constructor from 50 values 13,159 ops/sec [12,898..13,247] → 13,228 ops/sec [12,917..14,040] ~ overlap (+0.5%) 19,736 ops/sec [19,126..19,827] → 11,852 ops/sec [11,715..11,931] 🔴 -39.9%
add 50 object values 5,191 ops/sec [3,205..5,241] → 3,366 ops/sec [3,274..3,457] ~ overlap (-35.2%) 6,936 ops/sec [6,882..6,982] → 4,111 ops/sec [4,088..4,252] 🔴 -40.7%
has checks (50 values) 96,383 ops/sec [96,041..97,031] → 66,403 ops/sec [64,727..68,156] 🔴 -31.1% 169,577 ops/sec [168,937..170,002] → 167,306 ops/sec [165,838..167,881] 🔴 -1.3%
delete values 15,878 ops/sec [15,760..15,907] → 10,505 ops/sec [10,424..10,612] 🔴 -33.8% 17,510 ops/sec [16,960..17,800] → 17,362 ops/sec [17,089..17,425] ~ overlap (-0.8%)
non-registered symbol values 11,685 ops/sec [11,624..11,717] → 7,604 ops/sec [7,544..7,689] 🔴 -34.9% 15,642 ops/sec [9,409..15,861] → 15,636 ops/sec [15,490..15,653] ~ overlap (-0.0%)
forced gc pruning smoke 104 ops/sec [103..108] → 109 ops/sec [85..151] ~ overlap (+5.3%) 137 ops/sec [116..146] → 275 ops/sec [271..277] 🟢 +100.1%

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

Copy link
Copy Markdown
Contributor

test262 Conformance

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,335 +1 6 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,892 +2 1,401 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 (+2 / -0)

Newly passing (2):

  • built-ins/Number/prototype/toExponential/undefined-fractiondigits.js
  • intl402/DateTimeFormat/prototype/formatToParts/compare-to-temporal.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.

@frostney frostney merged commit 45194c5 into main Jun 28, 2026
15 checks passed
@frostney frostney deleted the claude/vigilant-dubinsky-2e22bf branch June 28, 2026 16:08
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

bug Something isn't working spec compliance Mismatch against official JavaScript/TypeScript specification

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant