Hmmm, it's kind of complicated. A lot of the innovation in JS frameworks has been at the meta framework level, because the client-side framework itself can't really control how data is loaded or how the app is bundled. A lot of work has been done to begin data fetching as quickly and in parallel as possible, like you said because network latency is a big factor for performance. And there is a focus on bringing down bundle sizes. I think Svelte 5 is only a few kb, same with Solid.js. The meta frameworks bring some added weight because they contain the routing and data loading logic.

But especially on mobile, rendering throughput as you put it is still relevant. Especially in response to interactions which cause significant changes to the UI. The "issue" with React is that it's all done at runtime, which does bring significant benefits but loses out on opportunities to optimise things which is what stuff like Solid, Svelte, and Vue's in-development Vapor mode take advantage of via static analysis. The benefit is performance, but you lose out on the dynamic nature of React. That is a tradeoff you need to choose when picking a framework.

Solid and Svelte are so close to vanilla JS levels of performance that you start thinking about how to optimise as if you were directly manipulating the DOM itself. Which is cool, in comparison with React you end up trying to optimise for React instead of the DOM. You still need virtualisation in a lot of cases regardless if you use React or Svelte.

I think the bigger attraction with Svelte and Solid, as well as Vue et al. is the signals / reactivity aspect. You can still tie yourself up in issues with that but it's a better mental model for a lot of developers compared to the pseudo-pure functional approach React takes. React's model can be a pain when you do need to escape-hatch to the dom itself, like you often do with complex animations, or interactions like drag-and-drop. If you can stick to pure React it can often be pretty clean.

React's compiler is designed to minimise redundant rerenders and object instantiation. It seems to help if you look at benchmarks. Still not nearly as quick as the static analysis approach because it doesn't change the underlying semantics (it's just doing stuff you would otherwise do manually for the most part).

So I would say it's still an issue, but so is latency and bundle sizes and that's also seen a lot of innovation and improvements.