How to implement this async effect

[Waelwindows]

Hi, I was reading A Substructural Type and Effect
System, and in page 14. They describe how to model async/await using effects in OCaml.

type _ Effect.t +=
Async: (unit -> 'a) -> ('a promise) Effect.t
| Await: 'a promise -> 'a Effect.t
| Yield: unit Effect.t

I tried implementing the same in Koka

value type promise<a,e>
    Pending(kont : list<a -> e ()>)
    Done(result : a)

effect async<e,a,h>
    fun async(f : () -> e a) : ref<h, promise<a,e>>
    ctl await(p : ref<h, promise<a,e>>) : a
    ctl switch() : ()

However, I couldn't model that await returns a with effect e.

Nonetheless, I tried writing their example

fun sonnet18()
    val t1 = async
        print("Shall ")
        switch()
        print("compare thee ")
        1+1
    val t2 = async
        print("I ")
        // t1.await
        print("summer's day.")
        2+2
    val r1 = t1.await
    print("to a ")
    val r2 = t2.await
    println(r1 + r2)
    ()

Now adding an effect handler

fun naive-runner1(body: () -> <async<e,b,h>|e> a): e a
    var tasks := []  // using list as a queue
    val next = fn()
        match tasks
            Nil -> ()
            Cons(x, xs) ->
                tasks := xs
                x()
    fun fulfil(p: ref<h, promise<a,e>>, c: () -> e a): <|e> ()   // Im not sure about this signature
        with handler
             fun async(f)
                 val new_prom = ref(Pending([]))
                 tasks := tasks.append([fn() { fulfil(new_prom, f) }])
                 new_prom
             ctl await(prom)
                 match !prom
                       Done(x) -> x
                       Pending(xs) ->
                            prom := Pending(xs.append([resume]))
                            next()
             ctl switch()
                 tasks := tasks.append([fn() { resume(()) }])
                 next()
        val res = c()
        match !p
              Done(_) -> ()
              Pending(ws) ->
                          p := Done(res)
                          ws.reverse().foreach fn(k)
                            tasks := tasks.append([fn() { k(res) }])
                          next()
                          ()
        ()
    val pmain = ref(Pending([]))
    fulfil(pmain, main)
    match pmain
          Done(x) -> x

However, this gets the compiler complaining

async.kk(56,57): type error: effects do not match
  context        :                                                    fn() { k(res) }
  term           :                                                         { k(res) }
  inferred effect: $e
  expected effect: <local<_h>,write<_h1>,read<_h1>,alloc<_h1>,div|_e1>

If i change

-    fun fulfil(p: ref<h, promise<a,e>>, c: () -> e a): <|e> ()
+    fun fulfil(p: ref<h, promise<a,e>>, c: () -> e a): <st<h>|e> ()

Instead i get,

async.kk(41,18): type error: types do not match (due to an infinite type)
  context      :                  await(prom)
                 ...
                                             next()
  term         :                  await
  inferred type: (prom : ref<_h1,promise<(),<div,local<_h>|_e>>>, resume : (()) -> <div,local<_h>|_e> ()) -> <st<_h1>,div,local<_h>|_e> ()
  expected type: (x : ref<_h1,promise<(),<local<_h>,div|_e>>>, k : (()) -> <st<_h1>,div,local<_h>|_e> ()) -> <st<_h1>,div,local<_h>|_e> ()
  hint         : give a type to the function definition?

How do I resolve this?