Let's do a quick history lesson
Everything started at Netscape, the first browser that ever existed. They at some point decided that it would be cool to have some way to execute logic in the browser. At that time, Java was the hottest shit, so let's do something like that.
So, why is it not meant to be?
The thing is that the language that was designed so quickly and got so popular, so it is nothing you just change overnight. Every new feature or behavior must be backwards-compatible. Of course, there is new stuff coming, but the essential flaws still exist.
Let's take for example the single threading, of course you can do things in the background, but you simply have no control about it. For initial pages and the use cases this was totally fine, also keeping in mind resources were more limited back in the days. With new generations of hardware coming out, it seems like the priority has changed. Everyone has a beefy machine, and even phones are mighty computers in your pocket. But that's only half of the truth. As with more power on devices, there are of course more things people try to implement.
We shift into a web-first approach where you just develop for the web platform and run it basically everywhere. VS Code, Slack, MS Teams are excellent examples that this is not fiction but reality for everyday use.
And these applications run to problems with the limitations almost every day, instead of addressing the actual problem (which is the language itself) we add new technologies on top of the problem.
But there is TypeScript, WebAssembly and many more now! — Almost a solution, somewhat.
Just another technology built to resolve difficulties that can't be entirely fixed this way. And the intention behind it is certainly not to replace it, but fixing the weak parts, by adding an alternative. As it seems, it works even for Photoshop! This is of course a great thing and already an addition that makes things easier.
But one thing is in common for all: They increase complexity at the end of the day.
More frameworks to the rescue
Most of the frameworks address issues that don't exist or are just caused by the language (or another framework/library). So again, instead of resolving the actual issue, we just add another layer of complexity.
Don't get me wrong, sometimes a framework just makes your life a lot easier, but most of the internals and so on are just so bloated and stuffed with unnecessary over-engineering. This results in slower performance and new difficulties, as large bundle sizes, which are then optimized using another layer of abstraction and tooling.
And there are definitely languages out there suited better for this large projects.
The never-ending story with the ecosystem
Adding a “native” alternative would be the real solution
Of course, adding more complexity for simple stuff would be a terrible idea. At the end, this is what makes the web so charming and powerful. That would be a lot easier to use. But let's see where WebAssembly will take us, hopefully in a better world with more optimization possible.
This is not a thing that will happen overnight, but one can dream! ;) There are definitely more than enough reason that it would make sense to do it.
After all, it is love and hate at the same time for me. It is a really universal language, but you sacrifice control, performance, and a lot of brain cells to take advantage of it.