Immutability is overrated

Immutability fine, but not always, right?!

As the author of Xania a javascript UI library I ask myself this question countless times.

Immutability as an unbreakable rule does not make sense to me and I have been thinking about this for years, Could you help me make sense of it? I've heard all the popular arguments but I am still not convinced, let me explain..

Sure I do agree on the importance of immutability, and to be very precise I dont argue that, but disallowing immutability always and in all cases feels like a handicap in programming languages or in some case libraries in language like JavaScript where mutability is possible but make it inconvient to work with mutable data.

Pure functions have side-effects

I found this article that inspired me investigate this more

take for example the functions f and wasm

function f(x, y) {
  return x + y;
}

function wasm(esi, ecx) {
  let eax = ecx;
  eax += esi;
  return eax;
}

It is generally accepted that f is pure, and it is. But wasm mutates the variable eax so it is generally accepted to say that wasm is inpure, but is it really?
Suprisingly wasm is kind of how f would look like if it was compiled to WASM. We can also image how wasm can be decompiled back to f, so without going deep into theory we can say f and wasm are the same, correct me if I am wrong but I think this is called isomorphic in category theory, because following rule applies...

| f o wasm == wasm o f == id

Despite the fact that wasm has mutations we should consider it as pure just as f because they are the same.
In general, a mutation does not always conclude if the given function is pure or not.

Rules for Mutability

Like in the article above by John D. Cook, pure functions only make sense at certain the level of abstraction. sounds like we can agree on it but this raises the question, what are pricesly those levels where we allow mutations in a pure function? Is the level boundary defined by the language runtime?
Is it thinkable to extend the mutation to the user code (even in haskell) if rules of mutability are satisfied?

This is where my brain starts to hurt. What are your thoughs and do you know if there are resources on this subject?