this solves the last invalid case but costs us two reasonable use cases

Author: lbialy

core/src/main/scala/ox/supervised.scala

@@ -3,10 +3,18 @@ package ox
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.{CompletableFuture, ConcurrentHashMap}
 import scala.reflect.ClassTag
+import scala.util.NotGiven
+import scala.util.boundary.Label
 
 sealed abstract class Supervised
 object SupervisedEvidence extends Supervised
 
+private inline def availableInScope[A]: Boolean =
+  compiletime.summonFrom {
+    case _: NotGiven[A] => false
+    case _: A           => true
+  }
+
 /** Starts a new concurrency scope, which allows starting forks in the given code block `f`. Forks can be started using [[fork]],
   * [[forkUser]], [[forkCancellable]] and [[forkUnsupervised]]. All forks are guaranteed to complete before this scope completes.
   *
@@ -27,7 +35,19 @@ object SupervisedEvidence extends Supervised
   * @see
   *   [[supervisedError]] Starts a scope in supervised mode, with the additional ability to report application errors
   */
-def supervised[T](f: Supervised ?=> Ox ?=> T): T = supervisedError(NoErrorMode)(f)
+inline def supervised[T](f: Supervised ?=> Ox ?=> T): T =
+  inline if availableInScope[Label[Either[Nothing, Nothing]]] && availableInScope[Forked] then
+    compiletime.error(
+      "Nesting supervised scopes along with fork and either blocks is disallowed to prevent unsafe .ok() combinator usage on forks."
+    )
+  else supervisedErrorInternal(NoErrorMode)(f)
+
+inline def supervisedError[E, F[_], T](em: ErrorMode[E, F])(f: Supervised ?=> OxError[E, F] ?=> F[T]): F[T] =
+  inline if availableInScope[Label[Either[Nothing, Nothing]]] && availableInScope[Forked] then
+    compiletime.error(
+      "Nesting supervised scopes along with fork and either blocks is disallowed to prevent unsafe .ok() combinator usage on forks."
+    )
+  else supervisedErrorInternal(em)(f)
 
 /** Starts a new concurrency scope, which allows starting forks in the given code block `f`. Forks can be started using [[fork]],
   * [[forkError]], [[forkUser]], [[forkUserError]], [[forkCancellable]] and [[forkUnsupervised]]. All forks are guaranteed to complete
@@ -39,7 +59,7 @@ def supervised[T](f: Supervised ?=> Ox ?=> T): T = supervisedError(NoErrorMode)(
   * @see
   *   [[forkError]] On details how to use application errors.
   */
-def supervisedError[E, F[_], T](em: ErrorMode[E, F])(f: Supervised ?=> OxError[E, F] ?=> F[T]): F[T] =
+def supervisedErrorInternal[E, F[_], T](em: ErrorMode[E, F])(f: Supervised ?=> OxError[E, F] ?=> F[T]): F[T] =
   val s = DefaultSupervisor[E]
   val capability = OxError(s, em)
   try

core/src/test/scala/ox/ForkEitherInteropTest.scala

@@ -196,35 +196,37 @@ class ForkEitherInteropTest extends AnyFlatSpec with Matchers {
          }
        }""" should compile
 
-    """
-       import ox.*
-       import ox.either.*
-
-       either {
-         supervised {
-           fork {
-             supervised {
-               Right(1).ok()
-             }
-           }
-         }
-       }""" should compile
-
-    """
-       import ox.*
-       import ox.either.*
-
-       either {
-         supervised {
-           fork {
-             supervised {
-               fork {
-                 Right(1).ok()
-               }
-             }
-           }
-         }
-       }""" should compile
+    // the new approach with supervised nesting prevention disallows these two examples but fixes last example in subsequent test
+
+//    """
+//       import ox.*
+//       import ox.either.*
+//
+//       either {
+//         supervised {
+//           fork {
+//             supervised {
+//               Right(1).ok()
+//             }
+//           }
+//         }
+//       }""" should compile
+
+//    """
+//       import ox.*
+//       import ox.either.*
+//
+//       either {
+//         supervised {
+//           fork {
+//             supervised {
+//               fork {
+//                 Right(1).ok()
+//               }
+//             }
+//           }
+//         }
+//       }""" should compile
 
     """
        import ox.*