[kyo-kernel][kyo-core] correct nested-computation resumption and fatal-error handling

Pending: map/flatMap/andThen deferred the resumption over the unwrapped value, so on resume the
loop took the bare-suspension branch and dropped its continuation, leaking the inner effect. Defer
over the original value so the resume re-applies the continuation.

IOTask: a fatal error re-thrown from eval skipped run's termination block, so the task's finalizers
never ran. Run the finalizers and release the trace on the fatal path before re-propagating.

IOPromise: eval's completion-callback catch was gated on NonFatal, so a fatal callback aborted the
flush loop and left the other waiters unnotified. Catch Throwable and log.

BytecodeTest: update the map anonfun size for the smaller Effect.defer thunk.

Author: fwbrasil

kyo-core/shared/src/main/scala/kyo/scheduler/IOPromise.scala

@@ -6,7 +6,6 @@ import kyo.*
 import kyo.Result.Error
 import kyo.kernel.internal.Safepoint
 import scala.annotation.tailrec
-import scala.util.control.NonFatal
 
 sealed private[kyo] trait IOPromiseBase[+E, +A]:
     self: IOPromise[E, A] =>
@@ -414,7 +413,11 @@ private[kyo] object IOPromise:
     private inline def eval[A](inline f: => Unit): Unit =
         try f
         catch
-            case ex if NonFatal(ex) =>
+            // Completion callbacks run in a single loop over all of a promise's waiters; a throwable escaping here
+            // would abort that loop and leave the remaining waiters unnotified. A callback is an isolated
+            // side-effecting notification, not the fiber's own computation, so contain and log every failure
+            // (fatal included) rather than propagate.
+            case ex =>
                 given Frame = Frame.internal
                 import AllowUnsafe.embrace.danger
                 Log.live.unsafe.error("uncaught exception", ex)

kyo-core/shared/src/main/scala/kyo/scheduler/IOTask.scala

@@ -126,7 +126,22 @@ sealed private[kyo] class IOTask[Ctx, E, A] private (
 
     final def run(startMillis: Long, clock: InternalClock, deadline: Long): Task.Result =
         val safepoint = Safepoint.get
-        val next      = eval(startMillis, clock, deadline)(using safepoint)
+        val next =
+            try eval(startMillis, clock, deadline)(using safepoint)
+            catch
+                case ex =>
+                    // A fatal error unwinds eval before the normal termination path below runs. The task's promise
+                    // is already completed with a Panic, but its finalizers would be skipped, stranding whatever
+                    // resource or awaited promise they release. Run the finalizers and release the trace, then
+                    // re-propagate the fatal.
+                    if !finalizers.isEmpty then
+                        finalizers.run(pollError())
+                        finalizers = Finalizers.empty
+                    if trace ne null then
+                        safepoint.releaseTrace(trace)
+                        trace = null.asInstanceOf[Trace]
+                    curr = nullResult
+                    throw ex
         if !isPending() then
             // On an interrupt that lands mid-slice, `next` is the accurate remainder whose head is the
             // suspension eval stopped in front of (for example an Async.Join), while `curr` is the stale

kyo-kernel/jvm/src/test/scala/kyo/kernel/BytecodeTest.scala

@@ -31,7 +31,7 @@ class BytecodeTest extends kyo.test.Test[Any]:
 
     "map" in {
         val map = methodBytecodeSize[TestMap]
-        assert(map == Map("test" -> 26, "anonfun" -> 11, "mapLoop" -> 151))
+        assert(map == Map("test" -> 26, "anonfun" -> 8, "mapLoop" -> 151))
     }
 
     "handle" in {

kyo-kernel/shared/src/main/scala/kyo/kernel/Pending.scala

@@ -76,7 +76,7 @@ object `<`:
                         // protocol this reproduces. A future protocol change updates that method
                         // AND this site.
                         if !safepoint.enter(_frame, value) then
-                            Effect.defer(mapLoop(value))
+                            Effect.defer(mapLoop(v))
                         else
                             try f(value): B < S2
                             finally safepoint.exit()
@@ -112,7 +112,7 @@ object `<`:
                         // protocol this reproduces. A future protocol change updates that method
                         // AND this site.
                         if !safepoint.enter(_frame, value) then
-                            Effect.defer(flatMapLoop(value))
+                            Effect.defer(flatMapLoop(v))
                         else
                             try f(value): B < S2
                             finally safepoint.exit()
@@ -145,7 +145,7 @@ object `<`:
                         // protocol this reproduces. A future protocol change updates that method
                         // AND this site.
                         if !safepoint.enter(_frame, value) then
-                            Effect.defer(andThenLoop(value))
+                            Effect.defer(andThenLoop(v))
                         else
                             try f: B < S2
                             finally safepoint.exit()