You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
Repository navigation
v26: computed property lookups with concatenated keys that miss keep every key alive (unbounded heap growth) #67505
v26.13.1 (V8 14.6.202.34-node.40). Also reproduced on v26.5.0. Also observed on Linux with v26.10.0.
Platform
Darwin arm64 (macOS); also Linux
Subsystem
V8
What steps will reproduce the bug?
A computed property load on a plain object, where the key is a freshly concatenated string and the property is absent, keeps every such key reachable for the life of the process. Heap grows without bound.
// node --expose-gc repro.mjs [concat|plain|hasOwn]consttable={};for(leti=0;i<300;i++)table[`key-${i}`]=i;constlookups={concat: (s)=>table[s+".x"],// grows without bound on Node 26plain: (s)=>table[s],// stablehasOwn: (s)=>Object.hasOwn(table,s+".x"),// stable};constlookup=lookups[process.argv[2]??"concat"];constheapMB=()=>{globalThis.gc();returnMath.round(process.memoryUsage().heapUsed/1048576);};console.log(process.version,process.argv[2]??"concat","start",heapMB(),"MB");for(letround=1;round<=8;round++){for(leti=0;i<400_000;i++)lookup(`some/unique/string-${Math.random()}-${i}`);console.log("after",round*400_000,"misses:",heapMB(),"MB");}
How often does it reproduce? Is there a required condition?
Every time on v26.x. The key has to come from a concatenation (s + ".x") and miss on the object. With a pre-existing string key (table[s]), Object.hasOwn, in or Map#has, the heap stays flat.
What is the expected behavior? Why is that the expected behavior?
Heap after gc() stays flat. That is what v20.20.2, v22.22.3, v24.15.0 and v24.18.0 (V8 13.6) do with the same script:
v24.18.0 concat start 3 MB
after 3200000 misses: 3 MB
What do you see instead?
v26.13.1 concat start 4 MB
after 400000 misses: 69 MB
after 800000 misses: 133 MB
after 1200000 misses: 182 MB
after 1600000 misses: 263 MB
after 2000000 misses: 312 MB
after 2400000 misses: 361 MB
after 2800000 misses: 474 MB
after 3200000 misses: 523 MB
plain and hasOwn stay at 3–4 MB on v26.13.1.
Additional information
In a heap snapshot, the retained key strings hang off large arrays (about 8 MB each, one per lookup site) that are referenced from the lookup function's FeedbackVector / FeedbackCell. So the keyed-load feedback seems to keep its keys strongly.
This shows up in practice in long-running HTTP servers. For example, a static-file check like assets[path + '.gz'] || assets[path + '.br'] running on every request turns every distinct request URL into permanent heap. We saw about 13 MB/h of growth, and processes got OOM-killed after a couple of days. Our workaround was to switch those lookups to Object.hasOwn.
Activity
Renegade334 commentedon Nov 18, 2026
Looks to be a V8 caching issue. For now, replacing
s1 + s2with a template string literal does suppress it.