How async functions(such as timers) inside promise are handled in Javascript? - asynchronous

Question

We know Promises are microtasks and they are added on microtask queue and event listeners/timers are tasks and so they are added on task queue. But what about the event-listeners/timers if they are inside of a promise function(which is passed on the creation of promise to promise constructor). In which queue are they get added?
console.log("script start");
var promise = new Promise(function (resolve, reject) {
setTimeout(function () {
console.log("setTimeout2");
resolve();
}, 0);
});
promise.then(function () {
console.log("promise2");
});
setTimeout(function () {
console.log("setTimeout");
}, 0);
console.log("script end");
Here "script start" is the part of main task so it gets executed/printed.
Then the callback function of the promise is handled to browser, the handler adds this to the microtask queue.
the then() pass the callback to the handler of the browser and it will execute after the main promise is resolved.
The setTimeout which is outside of the promise is added to the task queue.
The "script end" gets printed.
Now there are a microtask on the microtask queue and a task on task queue.
So the microtask will be executed first as they have higher priority than the task.
But inside the task, there is a timer.
We know the timers are added to the task queue. But here I think the timer is added to the microtask queue. Because if it was added to task queue then the "setTimeout2" would be printed later because on the task queue there is already a task which prints "setTimeout".
So what actually happens there?

Answer 1

There is nothing special about being "in a promise". The only functions that are put on the microtask queue are the callbacks passed into then.
Here's what's actually happening:
The script start log is executed
The promise is created and calls its executor callback. The executor callback calls setTimeout, which schedules a timer.
The promise is assigned to the promise variable
The then() method is called and attaches a fulfillment callback to the promise
The second setTimeout is called and schedules a second timer
The script end log is executed
This all happened synchronously in one task execution. After some time, the timers fire and (only then!) add their (macro) tasks to the timer event queue. The browser handles the first one:
The setTimeout2 log is executed
The resolve() function is executed which fulfills the promise and adds jobs to run the fulfillment callbacks to the microtask queue
After this macrotask is done, the tasks in the microtask queue are handled:
The promise2 log is executed
Since the microtask queue is empty already, the next macrotask can be handled:
The setTimeout log is executed