diff --git a/build.gradle b/build.gradle
index a0103e8..2d7841d 100644
--- a/build.gradle
+++ b/build.gradle
@@ -10,28 +10,28 @@
 
 java {
     toolchain {
-        languageVersion = JavaLanguageVersion.of(17)
+        languageVersion = JavaLanguageVersion.of(21)
     }
 }
 
 compileJava {
     options.compilerArgs << '-Xlint:unchecked'
     options.compilerArgs << '-Xlint:rawtypes'
-    options.release = 17
+    options.release = 21
 }
 
 compileTestJava {
     options.compilerArgs << '-Xlint:unchecked'
     options.compilerArgs << '-Xlint:rawtypes'
-    options.release = 17
+    options.release = 21
 }
 
 dependencies {
     api 'io.vavr:vavr:0.10.4'
 
-    testImplementation 'org.junit.jupiter:junit-jupiter:5.10.1'
-    testImplementation("org.mockito:mockito-core:5.7.0")
-    testImplementation("org.mockito:mockito-junit-jupiter:5.7.0")
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.10.2'
+    testImplementation("org.mockito:mockito-core:5.10.0")
+    testImplementation("org.mockito:mockito-junit-jupiter:5.10.0")
 }
 
 tasks.named('test') {
diff --git a/src/main/java/com/github/tonivade/vavr/effect/IO.java b/src/main/java/com/github/tonivade/vavr/effect/IO.java
index 64f59e1..4f13d46 100644
--- a/src/main/java/com/github/tonivade/vavr/effect/IO.java
+++ b/src/main/java/com/github/tonivade/vavr/effect/IO.java
@@ -52,7 +52,7 @@
   default Future<T> runAsync(Executor executor) {
     return forked(executor).andThen(this).runAsync();
   }
-  
+
   default T unsafeRunSync() {
     return safeRunSync().get();
   }
@@ -74,7 +74,7 @@
   }
 
   default <R> IO<R> flatMap(Function1<? super T, ? extends IO<? extends R>> map) {
-    return new FlatMapped<>(this, map.andThen(IO::narrowK));
+    return new FlatMapped<>(this, map);
   }
 
   default <R> IO<R> andThen(IO<? extends R> after) {
@@ -125,15 +125,15 @@
     return IO.task(System::nanoTime).flatMap(
       start -> map(result -> Tuple.of(Duration.ofNanos(System.nanoTime() - start), result)));
   }
-  
+
   default IO<Fiber<T>> fork() {
     return async(callback -> {
       IOConnection connection = IOConnection.cancellable();
       Promise<T> promise = runAsync(this, connection);
-      
+
       IO<T> join = fromFuture(promise.future());
       IO<Unit> cancel = exec(connection::cancel);
-      
+
       callback.accept(Try.success(Fiber.of(join, cancel)));
     });
   }
@@ -141,7 +141,7 @@
   default IO<T> timeout(Duration duration) {
     return timeout(Future.DEFAULT_EXECUTOR, duration);
   }
-  
+
   default IO<T> timeout(Executor executor, Duration duration) {
     return racePair(executor, this, sleep(duration)).flatMap(either -> either.fold(
         ta -> ta._2().cancel().map(x -> ta._1()),
@@ -163,7 +163,7 @@
   default IO<T> repeat(Duration delay, int times) {
     return repeat(Schedule.<T>recursSpaced(delay, times).zipRight(Schedule.identity()));
   }
-  
+
   default <B> IO<B> repeat(Schedule<T, B> schedule) {
     return repeatOrElse(schedule, (e, b) -> raiseError(e));
   }
@@ -195,7 +195,7 @@
   default IO<T> retry(Duration delay, int maxRetries) {
     return retry(Schedule.<Throwable>recursSpaced(delay, maxRetries));
   }
-  
+
   default <B> IO<T> retry(Schedule<Throwable, B> schedule) {
     return retryOrElse(schedule, (e, b) -> raiseError(e));
   }
@@ -220,23 +220,23 @@
   static <T> IO<T> pure(T value) {
     return new Pure<>(value);
   }
-  
+
   static <A, B> IO<Either<A, B>> race(IO<? extends A> fa, IO<? extends B> fb) {
     return race(Future.DEFAULT_EXECUTOR, fa, fb);
   }
-  
+
   static <A, B> IO<Either<A, B>> race(Executor executor, IO<? extends A> fa, IO<? extends B> fb) {
     return racePair(executor, fa, fb).flatMap(either -> either.fold(
         ta -> ta._2().cancel().map(x -> Either.left(ta._1())),
         tb -> tb._1().cancel().map(x -> Either.right(tb._2()))));
   }
-  
+
   static <A, B> IO<Either<Tuple2<A, Fiber<B>>, Tuple2<Fiber<A>, B>>> racePair(Executor executor, IO<? extends A> fa, IO<? extends B> fb) {
     return cancellable(callback -> {
-      
+
       IOConnection connection1 = IOConnection.cancellable();
       IOConnection connection2 = IOConnection.cancellable();
-      
+
       Promise<A> promiseA = runAsync(IO.forked(executor).andThen(fa), connection1);
       Promise<B> promiseB = runAsync(IO.forked(executor).andThen(fb), connection2);
 
@@ -294,12 +294,12 @@
   static <T> IO<T> fromEither(Either<Throwable, ? extends T> task) {
     return task.fold(IO::raiseError, IO::pure);
   }
-  
+
   static <T> IO<T> fromFuture(Future<? extends T> promise) {
     CheckedConsumer<Consumer<? super Try<? extends T>>> callback = promise::onComplete;
     return async(callback);
   }
-  
+
   static <T> IO<T> fromCompletableFuture(CompletableFuture<? extends T> promise) {
     return fromFuture(Future.fromCompletableFuture(promise));
   }
@@ -327,11 +327,11 @@
   static <T> IO<T> never() {
     return async(callback -> {});
   }
-  
+
   static IO<Unit> forked() {
     return forked(Future.DEFAULT_EXECUTOR);
   }
-  
+
   static IO<Unit> forked(Executor executor) {
     return async(callback -> executor.execute(() -> callback.accept(Try.success(Unit.unit()))));
   }
@@ -364,31 +364,31 @@
     return UNIT;
   }
 
-  static <T, R> IO<R> bracket(IO<? extends T> acquire, 
+  static <T, R> IO<R> bracket(IO<? extends T> acquire,
       Function1<? super T, ? extends IO<? extends R>> use, Function1<? super T, IO<Unit>> release) {
     return cancellable(callback -> {
-      
+
       IOConnection cancellable = IOConnection.cancellable();
-      
+
       Promise<? extends T> promise = runAsync(acquire, cancellable);
-      
+
       promise.future()
         .onFailure(error -> callback.accept(Try.failure(error)))
-        .onSuccess(resource -> runAsync(use.andThen(IO::narrowK).apply(resource), cancellable).future()
-          .onComplete(result -> runAsync(release.andThen(IO::narrowK).apply(resource), cancellable).future()
+        .onSuccess(resource -> runAsync(use.apply(resource), cancellable).future()
+          .onComplete(result -> runAsync(release.apply(resource), cancellable).future()
             .onComplete(ignore -> callback.accept(result))
         ));
-      
+
       return IO.exec(cancellable::cancel);
     });
   }
 
-  static <T, R> IO<R> bracket(IO<? extends T> acquire, 
+  static <T, R> IO<R> bracket(IO<? extends T> acquire,
       Function1<? super T, ? extends IO<? extends R>> use, CheckedConsumer<? super T> release) {
     return bracket(acquire, use, asFunction(release));
   }
 
-  static <T extends AutoCloseable, R> IO<R> bracket(IO<? extends T> acquire, 
+  static <T extends AutoCloseable, R> IO<R> bracket(IO<? extends T> acquire,
       Function1<? super T, ? extends IO<? extends R>> use) {
     return bracket(acquire, use, AutoCloseable::close);
   }
@@ -403,7 +403,7 @@
   }
 
   static <A> IO<Seq<A>> traverse(Executor executor, Seq<IO<A>> sequence) {
-    return sequence.foldLeft(pure(List.empty()), 
+    return sequence.foldLeft(pure(List.empty()),
         (IO<Seq<A>> xs, IO<A> a) -> parMap2(executor, xs, a, Seq::append));
   }
 
@@ -415,15 +415,15 @@
   static <A, B, C> IO<C> parMap2(Executor executor, IO<? extends A> fa, IO<? extends B> fb,
                               Function2<? super A, ? super B, ? extends C> mapper) {
     return cancellable(callback -> {
-      
+
       IOConnection connection1 = IOConnection.cancellable();
       IOConnection connection2 = IOConnection.cancellable();
-      
+
       Promise<A> promiseA = runAsync(IO.forked(executor).andThen(fa), connection1);
       Promise<B> promiseB = runAsync(IO.forked(executor).andThen(fb), connection2);
-      
+
       promiseA.future().onComplete(a -> promiseB.future().onComplete(b -> callback.accept(map2(a, b, mapper))));
-      
+
       return IO.exec(() -> {
         try {
           connection1.cancel();
@@ -453,20 +453,20 @@
   private static <T> Either<Throwable, T> toEither(Option<? extends T> task) {
     return task.fold(() -> Either.left(new NoSuchElementException()), Either::right);
   }
-  
+
   private static <A> A merge(Either<A, A> either) {
     return either.fold(Function1.identity(), Function1.identity());
   }
-  
+
   @SuppressWarnings("serial")
   private static <A, B> PartialFunction<A, B> partialFunction(Predicate<? super A> matcher, Function1<? super A, ? extends B> function) {
     return new PartialFunction<>() {
-      
+
       @Override
       public boolean isDefinedAt(A value) {
         return matcher.test(value);
       }
-      
+
       @Override
       public B apply(A t) {
         return function.apply(t);
@@ -493,29 +493,29 @@
     while (true) {
       try {
         current = unwrap(current, stack, identity());
-        
+
         if (current instanceof Pure<T> pure) {
           return promise.success(pure.value);
         }
-        
+
         if (current instanceof Async<T> async) {
           return executeAsync(async, connection, promise);
         }
-        
+
         if (current instanceof FlatMapped) {
           stack.push();
 
           var flatMapped = (FlatMapped<U, T>) current;
           IO<U> source = IO.narrowK(unwrap(flatMapped.current, stack, u -> u.flatMap(flatMapped.next)));
-          
+
           if (source instanceof Async<U> async) {
             Promise<U> nextPromise = Promise.make();
-            
+
             nextPromise.future().andThen(tryU -> tryU.onFailure(promise::failure)
                 .onSuccess(u -> runAsync(IO.narrowK(flatMapped.next.apply(u)), connection, stack, promise)));
-            
+
             executeAsync(async, connection, nextPromise);
-            
+
             return promise;
           }
 
@@ -531,7 +531,7 @@
         }
       } catch (Throwable error) {
         Option<IO<T>> result = stack.tryHandle(error);
-        
+
         if (result.isDefined()) {
           current = result.get();
         } else {
@@ -549,8 +549,7 @@
         stack.add(partialFunction(recover.mapper::isDefinedAt, recover.mapper.andThen(next)));
         current = recover.current;
       } else if (current instanceof Suspend<T> suspend) {
-        Supplier<IO<T>> andThen = () -> IO.narrowK(suspend.lazy.get());
-        current = andThen.get();
+        current = IO.narrowK(suspend.lazy.get());
       } else if (current instanceof Delay<T> delay) {
         return IO.pure(delay.task.unchecked().get());
       } else if (current instanceof Pure) {
@@ -569,11 +568,11 @@
     if (connection.isCancellable() && !connection.updateState(StateIO::startingNow).isRunnable()) {
       return promise.complete(Try.failure(new CancellationException()));
     }
-    
+
     connection.setCancelToken(current.callback.apply(promise::tryComplete));
-    
+
     promise.future().andThen(x -> connection.setCancelToken(UNIT));
-    
+
     if (connection.isCancellable() && connection.updateState(StateIO::notStartingNow).isCancellingNow()) {
       connection.cancelNow();
     }
@@ -686,7 +685,7 @@
 }
 
 final class Repeat<S, A, B, C> {
-  
+
   private final IO<A> current;
   private final ScheduleImpl<S, A, B> schedule;
   private final Function2<Throwable, Option<B>, IO<C>> orElse;
@@ -697,7 +696,7 @@
     this.schedule = (ScheduleImpl<S, A, B>) Objects.requireNonNull(schedule);
     this.orElse = Objects.requireNonNull(orElse);
   }
-  
+
   IO<Either<C, B>> run() {
     return current.attempt().flatMap(either -> either.fold(
         error -> orElse.apply(error, Option.none()).map(Either::<C, B>left),
@@ -706,9 +705,9 @@
 
   private IO<Either<C, B>> loop(A later, S state) {
     return schedule.update(later, state).flatMap(decision -> decision.fold(
-      ignore -> IO.pure(Either.right(schedule.extract(later, state))), 
+      ignore -> IO.pure(Either.right(schedule.extract(later, state))),
       s -> current.attempt().flatMap(either -> either.fold(
-        e -> orElse.apply(e, Option.some(schedule.extract(later, state))).map(Either::<C, B>left), 
+        e -> orElse.apply(e, Option.some(schedule.extract(later, state))).map(Either::<C, B>left),
         a -> loop(a, s)))));
   }
 }
@@ -735,34 +734,34 @@
       error -> {
         IO<Either<Unit, S>> update = schedule.update(error, state);
         return update.flatMap(decision -> decision.fold(
-          ignore -> orElse.apply(error, state).map(Either::<B, A>left), 
+          ignore -> orElse.apply(error, state).map(Either::<B, A>left),
           this::loop));
-      }, 
+      },
       a -> IO.pure(Either.right(a)))
       );
   }
 }
 
 sealed interface IOConnection {
-  
+
   IOConnection UNCANCELLABLE = new Uncancellable();
-  
+
   boolean isCancellable();
 
   void setCancelToken(IO<Unit> cancel);
-  
+
   void cancelNow();
-  
+
   void cancel();
-  
+
   StateIO updateState(UnaryOperator<StateIO> update);
-  
+
   static IOConnection cancellable() {
     return new Cancellable();
   }
-  
+
   static final class Uncancellable implements IOConnection {
-    
+
     private Uncancellable() { }
 
     @Override
@@ -790,7 +789,7 @@
       return StateIO.INITIAL;
     }
   }
-  
+
   static final class Cancellable implements IOConnection {
 
     private IO<Unit> cancelToken;
@@ -830,35 +829,35 @@
 }
 
 record StateIO(boolean isCancelled, boolean isCancellingNow, boolean isStartingNow) {
-  
+
   static final StateIO INITIAL = new StateIO(false, false, false);
   static final StateIO CANCELLED = new StateIO(true, false, false);
-  
+
   StateIO cancellingNow() {
     return new StateIO(isCancelled, true, isStartingNow);
   }
-  
+
   StateIO startingNow() {
     return new StateIO(isCancelled, isCancellingNow, true);
   }
-  
+
   StateIO notStartingNow() {
     return new StateIO(isCancelled, isCancellingNow, false);
   }
-  
+
   boolean isCancelable() {
     return !isCancelled && !isCancellingNow && !isStartingNow;
   }
-  
+
   boolean isRunnable() {
     return !isCancelled && !isCancellingNow;
   }
 }
 
 final class CallStack<T> {
-  
+
   private StackItem<T> top = new StackItem<>();
-  
+
   void push() {
     top.push();
   }
@@ -870,7 +869,7 @@
       top = top.prev();
     }
   }
-  
+
   void add(PartialFunction<? super Throwable, ? extends IO<? extends T>> mapError) {
     if (top.count() > 0) {
       top.pop();
@@ -878,12 +877,12 @@
     }
     top.add(mapError);
   }
-  
+
   Option<IO<T>> tryHandle(Throwable error) {
     while (top != null) {
       top.reset();
       Option<IO<T>> result = top.tryHandle(error);
-      
+
       if (result.isDefined()) {
         return result;
       } else {
@@ -892,7 +891,7 @@
     }
     return Option.none();
   }
-  
+
   // XXX: https://www.baeldung.com/java-sneaky-throws
   @SuppressWarnings("unchecked")
   <X extends Throwable, R> R sneakyThrow(Throwable t) throws X {
@@ -901,7 +900,7 @@
 }
 
 final class StackItem<T> {
-  
+
   private int count = 0;
   private final Deque<PartialFunction<? super Throwable, ? extends IO<? extends T>>> recover = new ArrayDeque<>();
 
@@ -914,27 +913,27 @@
   StackItem(StackItem<T> prev) {
     this.prev = prev;
   }
-  
+
   StackItem<T> prev() {
     return prev;
   }
-  
+
   int count() {
     return count;
   }
-  
+
   void push() {
     count++;
   }
-  
+
   void pop() {
     count--;
   }
-  
+
   void reset() {
     count = 0;
   }
-  
+
   void add(PartialFunction<? super Throwable, ? extends IO<? extends T>> mapError) {
     recover.addFirst(mapError);
   }
@@ -943,7 +942,7 @@
     while (!recover.isEmpty()) {
       var mapError = recover.removeFirst();
       if (mapError.isDefinedAt(error)) {
-        return Option.some(mapError.andThen(IO::<T>narrowK).apply(error));
+        return Option.some(IO.narrowK(mapError.apply(error)));
       }
     }
     return Option.none();
diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java
deleted file mode 100644
index 03f8505..0000000
--- a/src/main/java/module-info.java
+++ /dev/null
@@ -1,5 +0,0 @@
-module com.github.tonivade.vavr.effect {
-  exports com.github.tonivade.vavr.effect;
-
-  requires io.vavr;
-}
\ No newline at end of file
diff --git a/src/test/java/com/github/tonivade/vavr/effect/ScheduleTest.java b/src/test/java/com/github/tonivade/vavr/effect/ScheduleTest.java
index b6843f4..e604c76 100644
--- a/src/test/java/com/github/tonivade/vavr/effect/ScheduleTest.java
+++ b/src/test/java/com/github/tonivade/vavr/effect/ScheduleTest.java
@@ -31,16 +31,29 @@
   void repeat(@Mock Consumer<String> console) {
     IO<Unit> print = IO.exec(() -> console.accept("hola"));
     Schedule<Unit, Unit> schedule = Schedule.<Unit>recurs(2).zipRight(Schedule.identity());
-    
+
     IO<Unit> repeat = print.repeat(schedule);
-    
+
     Unit result = repeat.unsafeRunSync();
-    
+
     assertEquals(unit(), result);
     verify(console, times(3)).accept("hola");
   }
 
   @Test
+  void repeatStackSafe(@Mock Consumer<String> console) {
+    IO<Unit> print = IO.exec(() -> console.accept("hola"));
+    Schedule<Unit, Unit> schedule = Schedule.<Unit>recurs(10000).zipRight(Schedule.identity());
+
+    IO<Unit> repeat = print.repeat(schedule);
+
+    Unit result = repeat.unsafeRunSync();
+
+    assertEquals(unit(), result);
+    verify(console, times(10001)).accept("hola");
+  }
+
+  @Test
   void repeatDelay(@Mock Consumer<String> console) {
     IO<Unit> print = IO.exec(() -> console.accept("hola"));
     Schedule<Unit, Unit> recurs = Schedule.<Unit>recurs(2).zipRight(Schedule.identity());
@@ -49,20 +62,20 @@
 
     IO<Unit> repeat = print.repeat(schedule);
     IO<Tuple2<Duration, Unit>> timed = repeat.timed();
-    
+
     Tuple2<Duration, Unit> result = timed.unsafeRunSync();
-    
+
     assertTrue(result._1().toMillis() > 1000);
     verify(console, times(3)).accept("hola");
   }
-  
+
   @Test
   void noRepeat(@Mock Consumer<String> console) {
     IO<Unit> print = IO.exec(() -> console.accept("hola"));
     IO<Unit> repeat = print.repeat(Schedule.never());
-    
+
     Unit result = repeat.unsafeRunSync();
-    
+
     assertEquals(unit(), result);
     verify(console).accept("hola");
   }
@@ -75,9 +88,9 @@
 
     IO<String> read = IO.task(console::get);
     IO<String> retry = read.retry(Schedule.recurs(1));
-    
+
     String provide = retry.unsafeRunSync();
-    
+
     assertEquals("hola", provide);
     verify(console, times(2)).get();
   }
@@ -90,24 +103,24 @@
     Schedule<Throwable, Integer> recurs = Schedule.recurs(2);
     Schedule<Throwable, Integer> spaced = Schedule.spaced(Duration.ofMillis(500));
     IO<Tuple2<Duration, String>> retry = read.retry(recurs.zip(spaced)).timed();
-    
+
     Tuple2<Duration, String> result = retry.unsafeRunSync();
-    
+
     assertTrue(result._1().toMillis() > 500);
     assertEquals("hola", result._2());
     verify(console, times(2)).get();
   }
-  
+
   @Test
   void noRetry(@Mock Supplier<String> console) {
     when(console.get()).thenThrow(UnsupportedOperationException.class).thenReturn("hola");
-    
+
     IO<String> read = IO.task(console::get);
     IO<String> retry = read.retry(Schedule.never());
-    
+
     assertThrows(UnsupportedOperationException.class, retry::unsafeRunSync);
   }
-  
+
   @Test
   void andThen(@Mock Consumer<String> console) {
     Schedule<Unit, Integer> two =
@@ -115,13 +128,13 @@
 
     IO<Unit> print = IO.exec(() -> console.accept("hola"));
     IO<Integer> repeat = print.repeat(two);
-    
+
     Integer provide = repeat.unsafeRunSync();
-    
+
     assertEquals(1, provide);
     verify(console, times(3)).accept("hola");
   }
-  
+
   @Test
   @Disabled("I don't understand very well this")
   void compose(@Mock Consumer<String> console) {
@@ -130,22 +143,22 @@
 
     IO<Unit> print = IO.exec(() -> console.accept("hola"));
     IO<Integer> repeat = print.repeat(two);
-    
+
     Integer provide = repeat.unsafeRunSync();
-    
+
     assertEquals(Either.right(1), provide);
     verify(console, times(3)).accept("hola");
   }
-  
+
   @Test
   void collect() {
     IO<Unit> pure = IO.unit();
-    
+
     Schedule<Unit, Seq<Integer>> schedule = Schedule.<Unit>recurs(5).collectAll().zipLeft(Schedule.identity());
     IO<Seq<Integer>> repeat = pure.repeat(schedule);
-    
+
     Seq<Integer> result = repeat.unsafeRunSync();
-    
+
     assertEquals(List.of(0, 1, 2, 3, 4), result);
   }
 }