unsafeToFuture fails to raise a second InterruptedException if the exception is handled and retried

The code below catches a ExecutionException which wraps the Interrupted exception on the first iteration. On the second iteration no ExecutionException is thrown and the main thread blocks on the Await.

while(true){
  val f = IO{
       throw new InterruptedException("Test") 
    }.attempt.unsafeToFuture()(IORuntime.global)

  try{
    Await.result(f, Duration.Inf)
  } catch {
     case t:ExecutionException => println(s"Underlyng exception ${t.getCause}")
   }
}

I think the issue is in IOFiber.onFatalFailure specifically the line
if (IORuntime.globalFatalFailureHandled.compareAndSet(false, true))
On the first iteration globalFatalFailureHandled is initialised to false on the second iteration its now true so the code
block is never executed and the exception isn't raised.

If that is the case would adding a function like resetFatalFailureHandled be added to IORuntime to reset it if the future returned from unsafeToFuture has its ExecutionException handled and retried in a loop?

Start with the reproduction using IO.unsafeToFuture, Await.result, and the retry loop, then inspect IOFiber.onFatalFailure and IORuntime.globalFatalFailureHandled. Confirm the first iteration's handled ExecutionException changes subsequent behavior; done means repeated iterations consistently surface the interruption rather than block, with the runtime behavior verified against the proposed handling path.