Node.js event queues, Promises, and setTimeout() -- in what sequence?

In Node.js event queues, and code like "new Promise((r) => setTimeout(r, t));", is the setTimeout() evaluated NOW, in the microqueue for Promise resolves, or where?

The call to setTimeout is evaluated "now." (The setTimeout callback is called later as appropriate, during the time phrase.) When you do new Promise(fn), the Promise constructor calls fn immediately and synchronously, during your call to new Promise(fn). This is so the function (called an executor function) can start the asynchronous work that the promise will report on, as your two examples (one starts the work by calling setTimeout, the other by calling setImmediate.)

You can easily see this with logging:

console.log("Before");
new Promise((resolve, reject) => {
    console.log("During");
    setTimeout(() => {
        console.log("(fulfilling)");
        resolve();
    }, 10);
})
.then(
    () => {
        console.log("On fulfillment");
    },
    () => {
        console.log("On rejection");
    }
);
console.log("After");

That logs

Before
During
After
(fulfilling)
On fulfillment

because

• It calls console.log("Before"); before doing anything else.
• It calls new Promise and log console.log("During"); synchronously in the callback.
• It calls console.log("After"); after creating the promise and adding fulfillment and rejection handlers to it.
• It calls console.log("(fulfilling)"); when the timer fires and fulfill the promise.
• It calls console.log("On fulfillment"); when the fulfillment handler is called.

On your notes on the sequence:

• The "await sleep_st(0)" will have called setTimeout

Just to be really clear, it's specifically the sleep_st(0) part that called setTimeout. All await did was wait for the promise sleep_st returned after calling setTimeout to settle.

You may find this example useful, see inline comments:

const sleep = ms => new Promise(resolve => {
    // Happens immediately and synchronously when `sleep` is called
    console.log("calling setTimeout");
    setTimeout(() => {
        // Happens later, during the timer phase
        console.log("fulfilling promise");
        resolve(); // <=== If there are any attached promise handlers,
                   //      this queues calls to them in the microtask
                   //      queue, to be done after this "macro" task
                   //      running in the timer phase is complete
    }, ms);
});

const example = async (label) => {
    // Happens synchronously and immediately when `example` is called
    await sleep(0);
    // Happens in a microtask queued by the fulfillment of the promis
    console.log(`Sleep done: ${label}`);
};

(async () => {
    await Promise.all([example("a"), example("b")]);
    // Happens in a microtask queued by fulfillment of the `Promise.all`
    // promise
    console.log("All done");
})();

The output is:

calling setTimeout
calling setTimeout
fulfilling promise
Sleep done: a
fulfilling promise
Sleep done: b
All done

Note how the code for Sleep done: a was executed between the two tasks for the timer callbacks, because those timer callbacks are "macro" tasks and promise fulfillment callbacks are queued as microtask to be run at the end of the current macrotask.