Resolving fullfilled promise got stuck

[sammyne]

Just wondering why the line let _out = jsrt.resolve(p).await.context("resolve promise")?; is stuck, where the p is alreay fullfilled.

async fn call(jsrt: &mut JsRuntime, module_id: ModuleId) -> anyhow::Result<()> {
    let namespace = jsrt.get_module_namespace(module_id).context("get module namespace")?;
    let namespace = namespace.open(jsrt.v8_isolate().as_mut());

    // let event_loop = jsrt.run_event_loop(Default::default());

    let p = {
        let scope = &mut jsrt.handle_scope();

        let name = v8::String::new(scope, "world").context("fn name as v8 string")?.into();
        let f = namespace
            .get(scope, name)
            .ok_or_else(|| anyhow::anyhow!("miss fn"))?
            .cast::<v8::Function>();

        let undef = v8::undefined(scope);

        let args = ["sammyne"]
            .iter()
            .map(|v| serde_v8::to_v8(scope, v))
            .collect::<Result<Vec<_>, _>>()
            .context("convert args to v8 values")?;

        let r = f.call(scope, undef.into(), &args).context("call fn")?;

        Global::new(scope, r)
    };

    // Global::new(jsrt.v8_isolate(), promise);
    // event_loop.await.context("run event loop")?;
    jsrt.run_event_loop(Default::default())
        .await
        .context("run event loop")?;

    {
        let s = &mut jsrt.handle_scope();

        let p = Local::new(s, &p);
        let promise = p.try_cast::<Promise>().context("try cast to promise")?;
        println!("promise: {:?}", promise.open(s).state());
    }

    // this call is stuck~
    let _out = jsrt.resolve(p).await.context("resolve promise")?;

    Ok(())
}

[CyanChanges]

idk, supposely microtick checkpoint or something