MaybeLocal<Value> result;

auto run = [&]() {

MaybeLocal<Value> result = module->Evaluate(context);

if (!result.IsEmpty() && microtask_queue)

Local<Value> res;

if (result.ToLocal(&res) && microtask_queue) {

DCHECK(res->IsPromise());

// To address https://github.com/nodejs/node/issues/59541 when the

// module has its own separate microtask queue in microtaskMode

// "afterEvaluate", we avoid returning a promise built inside the

// module's own context.

//

// Instead, we build a promise in the outer context, which we resolve

// with {result}, then we checkpoint the module's own queue, and finally

// we return the outer-context promise.

//

// If we simply returned the inner promise {result} directly, per

// https://tc39.es/ecma262/#sec-newpromiseresolvethenablejob, the outer

// context, when resolving a promise coming from a different context,

// would need to enqueue a task (known as a thenable job task) onto the

// queue of that different context (the module's context). But this queue

// will normally not be checkpointed after evaluate() returns.

//

// This means that the execution flow in the outer context would

// silently fall through at the statement (in lib/internal/vm/module.js):

// await this[kWrap].evaluate(timeout, breakOnSigint)

//

// This is true for any promises created inside the module's context

// and made available to the outer context, as the node:vm doc explains.

//

// We must handle this particular return value differently to make it

// possible to await on the result of evaluate().

Local<Context> outer_context = isolate->GetCurrentContext();

Local<Promise::Resolver> resolver;

if (!Promise::Resolver::New(outer_context).ToLocal(&resolver)) {

return MaybeLocal<Value>();

}

if (resolver->Resolve(outer_context, res).IsNothing()) {

return MaybeLocal<Value>();

}

result = resolver->GetPromise();

microtask_queue->PerformCheckpoint(isolate);

}

return result;

};

if (break_on_sigint && timeout != -1) {