Let's talk closures. How does a closure end up leaking memory? And be precise with me about what a function actually holds onto.
Strong answers know capture is per-variable into a heap context, and that closures born in one scope share it, the mechanism behind the classic pin
So a closure keeps a reference to the variables from its enclosing scope, which means as long as the closure itself is reachable, those variables can't get garbage collected. The leak pattern is basically a long-lived closure capturing something large. Like an event handler or a setInterval callback that references a big object, that object stays alive for as long as the handler stays registered. The fix is to remove listeners when you don't need them anymore, clear your intervals, and avoid capturing large objects in callbacks that outlive the request. Copy out the one field you actually need instead of holding the whole object. In heap snapshots these show up as objects retained by closures. A closure retains its captured variables, so a leaked or forgotten closure leaks everything it captured, or something like that.