Skip to content

perf(engine): trim Date shim slot fan-out and binary-search timezone lookup#897

Merged
frostney merged 1 commit into
mainfrom
claude/zen-gates-54c823
Jun 28, 2026
Merged

perf(engine): trim Date shim slot fan-out and binary-search timezone lookup#897
frostney merged 1 commit into
mainfrom
claude/zen-gates-54c823

Conversation

@frostney

Copy link
Copy Markdown
Owner

Summary

  • RCA first. Issue dst-offset-caching DST tests time out at 20s #829 hypothesised the staging/sm/Date/dst-offset-caching-*-of-8.js timeouts came from uncached DST-offset recomputation in Goccia.Temporal.TimeZone.pas. Profiling (macOS sample, prod bytecode build, pinned test262 SHA) refuted that: GetUtcOffsetSeconds / GetSystemTimeZoneId / BinarySearchTransitions appear in 0 of ~9,800 samples, and on a UTC host (GitHub runners) the offset path short-circuits to 0 entirely. The test is the SpiderMonkey SunSpider DST-cache stress test — a 4-deep nested loop doing ~3M new Date(NaN); setTime; getTimezoneOffset per shard — so the cost is the JS Date shim's per-call machinery, not the offset code. Per maintainer direction: fix the genuinely-ineffective machinery, keep Date in JS (hard line), no plaster.
  • Date shim slot fan-out (source/units/Goccia.Shims.pas). The [[DateValue]] stays in a WeakMap — the only non-observable slot store (a private field isn't viable: the exported Date is a function constructor so instances aren't class-private-bearing, and a symbol key would leak via getOwnPropertySymbols). Collapsed the helper fan-out: hot accessors now do a single WeakMap.get with === undefined as the brand check (a slot is always a number, never undefined), plus a numeric fast-path in __GocciaDateFromSingleArgument and a single-read #local/#utc. ~1.52× on the test's exact inner call (new Date(NaN); setTime; getTimezoneOffset: 114.0 → 74.7 µs/call; rigorous git stash A/B with an identical m1 normalizer).
  • Timezone canonicalization (source/units/Goccia.Temporal.TimeZone.pas). IsSupportedCanonicalTimeZoneIdentifier linearly scanned the ~446-entry available-zone list on every ZonedDateTime time-zone canonicalization. The list is already CompareStr-sorted (SortTimeZoneIdentifiers), so it now binary-searches (O(n) → O(log n)). ~1.20× on named-zone construction (9.10 → 7.52 µs/call). Matches the project's existing O(1)/O(k) lookup pattern (perf(engine): make for-in key dedup O(k) with a hash set #888 / perf(engine): back strong Map/Set with a SameValueZero-keyed ordered hash #890).
  • Non-goal / constraint: Date is not moved native (maintainer hard line). This does not make the 8 dst shards pass — see below.
  • Refs Performance micro-optimizations #819, dst-offset-caching DST tests time out at 20s #829. (Deliberately not Closes #829 — see the divergence note.)

⚠️ Divergence from the literal issue

Clearing the 20 s deadline needs ~15×, but the test's intrinsic new Date; setTime is already ~67 µs/call before any timezone work, and the residual is diffuse, inherent interpreter overhead (is/InheritsFrom type dispatch ~15%, scope-binding lookups ~8.5%, allocation ~12%, exception-frame setup ~8.5%) — already largely optimised by prior PRs. Closing the gap would need either native Date hot-ops (excluded) or a larger interpreter-throughput effort (e.g. a value-kind type tag, a global-binding inline cache). The shards still cleanly time out (Wrapper-infra 0, no crash). Recommend tracking the interpreter-throughput residual as a follow-up under the #819 perf umbrella, and leaving the close decision on #829 to the maintainer.

Testing

  • Verified no regressions and confirmed the new feature or bugfix in end-to-end JavaScript/TypeScript tests
  • Updated documentation — no docs change needed: internal perf only, no observable behaviour/API change (Date semantics and time-zone canonicalization are identical; brand-check and RangeError paths preserved).
  • Optional: Verified no regressions and confirmed the new feature or bugfix in native Pascal tests (if AST, scope, evaluator, or value types changed) — N/A: no AST/scope/evaluator/value-type changes; the touched Pascal is a leaf canonicalization helper.
  • Optional: Verified no benchmark regressions or confirmed benchmark coverage for the change

Details

  • Full JS suite: interpreter 10990 / 0 failed, bytecode 10990 / 0 failed.
  • ./format.pas --check: clean (372 files). Pre-commit hooks (trunc-guards, format) pass.
  • Benchmarks benchmarks/temporal.js both modes (incl. ZonedDateTime.from named time zone and since across DST, which exercise the binary search): run clean, no regression.
  • Targeted Date + Temporal: 546 / 546 both modes.
  • New regression tests:
    • tests/built-ins/Date/methods.js — slot-requiring methods reject a plain non-Date receiver ({} and Object.create(Date.prototype), which has the prototype but no slot) → TypeError; constructor reads the time value from a Date argument and clips numbers / NaN.
    • tests/built-ins/Temporal/ZonedDateTime/constructor.js — canonical named zones across the sorted lookup are preserved; a bad zone throws RangeError.
  • Under the canonical test262 harness (run_test262_suite.ts, --mode=bytecode --timeout-ms=20000), dst shard 1 still classifies as timeout/FAIL with Wrapper-infra 0 (no crash) — expected per the divergence note.

🤖 Generated with Claude Code

…lookup

RCA of the staging/sm/Date/dst-offset-caching timeouts (#829): profiling
showed the cost is the JS Date shim's per-call machinery, not DST-offset
recomputation (the offset code profiles at 0 samples and short-circuits on
UTC hosts). Per maintainer direction, fix the genuinely-ineffective code with
Date staying in JS.

- Goccia.Shims.pas: the Date [[DateValue]] stays in a WeakMap (only
  non-observable slot store), but the hot accessors now do a single
  WeakMap.get with `=== undefined` as the brand check (a slot is always a
  number, never undefined), plus a numeric fast-path in
  __GocciaDateFromSingleArgument and a single-read #local/#utc. ~1.52x on
  `new Date(NaN); setTime; getTimezoneOffset`.
- Goccia.Temporal.TimeZone.pas: IsSupportedCanonicalTimeZoneIdentifier
  scanned the ~446-entry available-zone list linearly on every ZonedDateTime
  canonicalization; the list is already CompareStr-sorted, so use a binary
  search. ~1.20x on named-zone construction.

Does not clear the 20s deadline (needs ~15x; residual is inherent
interpreter overhead). Refs #819, #829.

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 8:26am

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: 72891ace-8449-4b4b-81a2-f96683d3b880

📥 Commits

Reviewing files that changed from the base of the PR and between 0662265 and a875ae0.

📒 Files selected for processing (4)
  • source/units/Goccia.Shims.pas
  • source/units/Goccia.Temporal.TimeZone.pas
  • tests/built-ins/Date/methods.js
  • tests/built-ins/Temporal/ZonedDateTime/constructor.js

📝 Walkthrough

Walkthrough

Fixes the embedded JavaScript Date shim's brand-check, slot accessor, and local/utc accessor logic; adds a numeric fast-path in the single-argument converter; replaces the O(n) linear scan in IsSupportedCanonicalTimeZoneIdentifier with an O(log n) binary search; and adds new test cases for Date prototype slot validation, Date constructor copying, and Temporal.ZonedDateTime canonical timezone acceptance.

Changes

Date Shim Fixes, Timezone Binary Search, and Tests

Layer / File(s) Summary
Date shim slot validation and accessors
source/units/Goccia.Shims.pas
Brand check changed to WeakMap.get(date) !== undefined; numeric fast-path added to single-arg converter via __GocciaDateTimeClip; __GocciaDateRequire/__GocciaDateGetSlot rewritten to throw on undefined from WeakMap.get; #local and #utc compute ms once, check Number.isFinite, and construct Temporal.ZonedDateTime or return null.
IsSupportedCanonicalTimeZoneIdentifier binary search
source/units/Goccia.Temporal.TimeZone.pas
O(n) linear loop replaced with O(log n) binary search using CompareStr over the sorted result of GetAvailablePrimaryTimeZoneIdentifiers.
Date and ZonedDateTime tests
tests/built-ins/Date/methods.js, tests/built-ins/Temporal/ZonedDateTime/constructor.js
New tests verify TypeError on non-Date receivers, Date-from-Date time value copying, NaN propagation through getTime()/getTimezoneOffset(), and Temporal.ZonedDateTime acceptance/rejection of canonical timezone identifiers.

Estimated code review effort

🎯 2 (Simple) | ⏱️ ~10 minutes

Possibly related issues

Possibly related PRs

  • frostney/GocciaScript#330: This PR's Date shim slot changes build directly on the Date shim infrastructure introduced in that PR.
  • frostney/GocciaScript#778: Both PRs modify IsSupportedCanonicalTimeZoneIdentifier and timezone identifier support in Goccia.Temporal.TimeZone.pas.

Suggested labels

performance

🚥 Pre-merge checks | ✅ 3 | ❌ 2

❌ Failed checks (2 warnings)

Check name Status Explanation Resolution
Linked Issues check ⚠️ Warning The PR does not implement the linked DST-offset caching fix and explicitly says the 20s shard timeout remains unresolved. Add caching or precomputation in DST-offset handling so the dst-offset-caching tests finish under 20s and the related staging failures clear.
Out of Scope Changes check ⚠️ Warning The Date-shim and timezone-canonicalization optimizations go beyond the linked issue's DST-offset caching scope. Limit the change to DST-offset caching/precomputation, or update the linked issue if these broader perf fixes are intended.
✅ Passed checks (3 passed)
Check name Status Explanation
Title check ✅ Passed The title is concise and accurately summarizes the two main performance changes in the PR.
Description check ✅ Passed The description follows the template with Summary and Testing sections and includes implementation constraints and results.
Docstring Coverage ✅ Passed No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

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

@github-actions

Copy link
Copy Markdown
Contributor

Suite Timing

Test Runner (interpreted: 10,990 passed; bytecode: 10,990 passed)
Metric Interpreted Bytecode
Total 10990 10990
Passed 10990 ✅ 10990 ✅
Workers 4 4
Test Duration 14.82s 18.62s
Lex (cumulative) 375.1ms 550.8ms
Parse (cumulative) 271.3ms 383.0ms
Compile (cumulative) 787.5ms
Execute (cumulative) 40.2ms 42.87s
Engine Total (cumulative) 686.6ms 44.59s
Lex (avg/worker) 93.8ms 137.7ms
Parse (avg/worker) 67.8ms 95.7ms
Compile (avg/worker) 196.9ms
Execute (avg/worker) 10.1ms 10.72s
Engine Total (avg/worker) 171.7ms 11.15s

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 282.89 MiB 280.31 MiB
GC Peak Live 344.21 MiB 318.09 MiB
GC Allocated During Run 529.35 MiB 473.50 MiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 195 195
GC Collected Objects 2,598,759 2,168,887
Heap Start Allocated 182.0 KiB 182.0 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 3.04min 2.78min

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 104.18 MiB 63.83 MiB
GC Allocated During Run 16.73 GiB 9.75 GiB
GC Limit 7.81 GiB 7.81 GiB
GC Collections 3,698 3,598
GC Collected Objects 265,238,689 219,524,484
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: 🟢 27 improved · 🔴 28 regressed · 381 unchanged · avg +0.0%
Bytecode: 🟢 31 improved · 🔴 44 regressed · 361 unchanged · avg -0.1%

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

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

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,334 ±0 7 99.8% ±0pp
language 23,711 23,711 ±0 0 100.0% ±0pp
staging 1,482 1,111 ±0 371 75.0% ±0pp
total 52,293 50,891 +1 1,402 97.3% ±0pp

Areas closest to 100%

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

Newly passing (1):

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

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

@frostney frostney marked this pull request as ready for review June 28, 2026 09:16
@coderabbitai coderabbitai Bot added the performance Performance improvement label Jun 28, 2026
@frostney frostney merged commit 6459b44 into main Jun 28, 2026
15 checks passed
@frostney frostney deleted the claude/zen-gates-54c823 branch June 28, 2026 09:28
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

performance Performance improvement

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant