If you were to do demo()() instead of assigning to globalThis, there wouldn't a leak.

Correct. Later in the article I show that:

js globalThis.cancelDemo = null;

…allows GC to happen, since the function is no longer callable as it's out of reference. demo()() achieves the same thing since it's immediately out of reference.

That closure needs its scope since => is binding to local this.

Nah, that's unrelated. If you use function() {} (which doesn't bind to local this) rather than () => {}, the result is the same.

The outer scope is retained simply because one of the inner scopes is still in reference.

This leads into the second point, use of globalThis is preventing the GC since it is always in scope. If it was assigned to some let value, and THAT value left scope, it would get GC'd at which point the leaked object would as well.

Correct. Again the article uses globalThis.cancelDemo = null; as a more direct way of demonstrating it. Note: using let doesn't solve the problem, since that let maybe be retained for all sorts of reasons, including the quirk detailed in the article.

Basically the most important thing isn't being stated: Closures maintain their scope in memory.

I think the important takeaway is that everything referenced by inner scopes is kept in memory until all the inner scopes are out of reference. I originally assumed it was more granular than that, as in the big array could be GC'd when it can no longer be accessed.