Skip to content

Enforce private static brand checks#168

Merged
frostney merged 1 commit into
mainfrom
fix/private-static-write-brand-checks
Apr 2, 2026
Merged

Enforce private static brand checks#168
frostney merged 1 commit into
mainfrom
fix/private-static-write-brand-checks

Conversation

@frostney
Copy link
Copy Markdown
Owner

@frostney frostney commented Apr 2, 2026

Summary

  • Enforces brand checks for private static field and accessor access so inherited static calls can no longer read or write a base class's private static state through this.
  • Adds compiler and VM support for tracking declared private static names and rejecting invalid cross-class writes.
  • Expands class private static tests to cover subclass reads, writes, and accessor cases that should throw TypeError.
  • Updates the tutorial to document the private static brand-check behavior.

Testing

  • Added/updated JavaScript coverage in tests/language/classes/private-static-fields.js for subclass receiver reads, writes, and accessor writes.
  • Not run: ./build.pas testrunner && ./build/TestRunner tests.
  • Not run: native Pascal test suite build and execution.

Summary by CodeRabbit

Release Notes

  • Documentation

    • Updated the Classes section with behavioral clarification on private static field access patterns.
  • Tests

    • Added test cases verifying private static field brand checking for both direct and inherited access scenarios.
  • Bug Fixes

    • Implemented brand validation for private static fields to prevent subclass receivers from accessing parent class private static state.

- Reject inherited `this.#name` reads and writes on static private members
- Add bytecode support for declared private static names
- Cover the behavior with class tests and tutorial docs
@coderabbitai
Copy link
Copy Markdown
Contributor

coderabbitai Bot commented Apr 2, 2026

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info
⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: 527c1d5b-28df-46c8-a291-937a5b8b2e00

📥 Commits

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

📒 Files selected for processing (7)
  • docs/tutorial.md
  • tests/language/classes/private-static-fields.js
  • units/Goccia.Bytecode.pas
  • units/Goccia.Compiler.Statements.pas
  • units/Goccia.Evaluator.pas
  • units/Goccia.VM.pas
  • units/Goccia.Values.ClassValue.pas

📝 Walkthrough

Walkthrough

This pull request implements "brand" checking for private static fields across the GocciaScript runtime. Subclass receivers are now rejected when accessing or mutating base class private static state, enforced through compiler opcodes, evaluator validation, and VM execution handlers.

Changes

Cohort / File(s) Summary
Documentation & Tests
docs/tutorial.md, tests/language/classes/private-static-fields.js
Added tutorial clarification and comprehensive test coverage for private static field brand checking, including scenarios with direct field access and private accessor behavior across inheritance hierarchies.
Bytecode Definition
units/Goccia.Bytecode.pas
Introduced new opcode OP_CLASS_DECLARE_PRIVATE_STATIC_CONST = 70 to represent private static field declaration instructions.
Compilation Layer
units/Goccia.Compiler.Statements.pas
Updated CompileClassDeclaration and CompileClassExpression to emit OP_CLASS_DECLARE_PRIVATE_STATIC_CONST instructions before setting private static properties.
Evaluation & Validation
units/Goccia.Evaluator.pas
Added EnsurePrivateStaticBrand helper that validates receiver class matches the access class; integrated brand checks into both read and write paths for private static members, throwing TypeError on mismatch.
Virtual Machine Execution
units/Goccia.VM.pas
Implemented handler for OP_CLASS_DECLARE_PRIVATE_STATIC_CONST opcode and updated SetPropertyValue to enforce brand checking during private static property assignments.
Class Value Introspection
units/Goccia.Values.ClassValue.pas
Added HasOwnPrivateStaticProperty and HasOwnPrivateStaticName methods to query private static property presence and validate brand membership.

Sequence Diagram

sequenceDiagram
    participant Compiler
    participant VM as VM/Runtime
    participant Evaluator
    participant ClassValue
    
    Compiler->>VM: Emit OP_CLASS_DECLARE_PRIVATE_STATIC_CONST<br/>(class, name, 0)
    VM->>ClassValue: Add private static property<br/>with name as key
    
    Note over Evaluator,ClassValue: Later: Read/Write Operation
    
    Evaluator->>ClassValue: Query HasOwnPrivateStaticName(key)
    ClassValue-->>Evaluator: Name exists in class
    
    alt Brand Check Success
        Evaluator->>ClassValue: Read/Write to private static
        ClassValue-->>Evaluator: Value returned/set
    else Brand Check Failure
        Evaluator->>Evaluator: EnsurePrivateStaticBrand fails
        Evaluator-->>VM: Throw TypeError
    end
Loading

Estimated Code Review Effort

🎯 3 (Moderate) | ⏱️ ~25 minutes

Possibly Related Issues

Poem

🐰 Static fields so private and dear,

Brand checks keep the line crystal clear!

Derived classes must retreat with grace—

Base's secrets stay in their rightful place. ✨

🚥 Pre-merge checks | ✅ 3
✅ Passed checks (3 passed)
Check name Status Explanation
Description Check ✅ Passed Check skipped - CodeRabbit’s high-level summary is enabled.
Title check ✅ Passed The pull request title clearly and specifically summarizes the main change: enforcing private static brand checks to prevent inherited static calls from accessing base class private static state.
Docstring Coverage ✅ Passed No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

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

✨ Finishing Touches
📝 Generate docstrings
  • Create stacked PR
  • Commit on current branch
🧪 Generate unit tests (beta)
  • Create PR with unit tests
  • Commit unit tests in branch fix/private-static-write-brand-checks

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

❤️ Share

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

@frostney
Copy link
Copy Markdown
Owner Author

frostney commented Apr 2, 2026

Fixes #150

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented Apr 2, 2026

Benchmark Results

263 benchmarks

Interpreted: 🟢 246 improved · 🔴 4 regressed · 13 unchanged · avg +7.7%
Bytecode: 🟢 54 improved · 🔴 84 regressed · 125 unchanged · avg -0.0%

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

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

@github-actions
Copy link
Copy Markdown
Contributor

github-actions Bot commented Apr 2, 2026

Suite Timing

Suite Metric Interpreted Bytecode
Tests Total 3564 3564
Tests Passed 3523 ✅ 3564 ✅
Tests Skipped 41 0
Tests Execution 183.4ms 179.4ms
Tests Engine 342.1ms 605.9ms
Benchmarks Total 263 263
Benchmarks Duration 7.16min 6.02min

Measured on ubuntu-latest x64.

@frostney frostney merged commit d1ebbb8 into main Apr 2, 2026
9 checks passed
@frostney frostney deleted the fix/private-static-write-brand-checks branch April 2, 2026 22:43
@frostney frostney added the new feature New feature or request label Apr 9, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

new feature New feature or request

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant