1. When accesses are resolved dynamically, the failure mode is better controlled, e.g. exception instead of buffer overflow.
2. The failure is deferred to the point of execution (instead of e.g. load time). It is easy to omit features that depend on missing runtime support, just arrange for that code to not be executed.
3. Dynamic types allow you to interrogate which interfaces are supported, via reflection.
We see all of this at work in (good) web sites. They gracefully degrade, they can dynamically choose implementations based on what the browser supports, and failures are JS exceptions instead of aborts.
> In practice, of course, that's a bigger problem with interpreted than compiled languages
Why does interpreted vs compiled matter? IMO the key distinction is dynamic linking vs static linking. When you link against code compiled after yours, the less assurance static types give, and the more important dynamic types become.
> static languages are no worse than dynamic ones
The proper comparison is between languages with dynamic types and languages without. TypeScript has both static and dynamic types. If it had no dynamic types, it would not be a viable JS replacement.
Dynamic typing changes a little bit about how the solutions are implemented, but not the difficulty or even the basic logical approach.
In any case, your example is one in which static languages are no worse than dynamic ones, so it is not one which prevents static languages from displacing dynamic of they are otherwise superior.