Each iteration ("tick") of the event loop goes through these phases in order:

   ┌──────────────────────────────────────────────────────┐
   │                                                      │
   │  1. timers        setTimeout / setInterval callbacks │
   │  2. pending I/O   I/O callbacks deferred to next tick│
   │  3. idle/prepare  (internal libuv use only)          │
   │  4. poll          wait for new I/O events            │
   │  5. check         setImmediate() callbacks           │
   │  6. close events  socket.on('close', ...) etc.       │
   │                                                      │
   └──────────────────────────────────────────────────────┘
   Between EVERY phase transition:
     → drain all process.nextTick() callbacks
     → drain all Promise microtasks (resolved .then / async continuations)

console.log('1: synchronous')

setTimeout(() => console.log('5: setTimeout'), 0)
setImmediate(() => console.log('6: setImmediate'))

Promise.resolve().then(() => console.log('3: Promise microtask'))
process.nextTick(() => console.log('2: nextTick'))

queueMicrotask(() => console.log('4: queueMicrotask'))

Poll phase behaviour:
  1. If there are pending timers (setTimeout/setInterval) that have expired → exit poll, run timers phase
  2. If there are I/O callbacks queued → execute them (up to system limits)
  3. Otherwise → BLOCK here, waiting for:
       • new I/O events from the OS (file reads, network data, etc.)
       • a timer to expire (sets the block timeout)
       • a setImmediate to be scheduled (unblocks immediately)

This is where Node waits for work. A healthy event loop spends most time here.

// ❌ BLOCKS the event loop — no other request can be served during this:
app.get('/report', (req, res) => {
  const result = computeHeavyReport()   // 200ms of pure CPU work
  res.json(result)
  // Every other in-flight request is frozen for 200ms
})

// ✅ CPU work offloaded to a worker thread — event loop stays free:
import { Worker } from 'node:worker_threads'
app.get('/report', (req, res) => {
  const worker = new Worker('./report-worker.js')
  worker.on('message', (result) => res.json(result))
  worker.on('error', (err) => res.status(500).json({ error: err.message }))
  worker.postMessage({ params: req.query })
})

// Measure event loop lag: schedule a 1ms timer and see how late it fires
function measureELLag(): number {
  const start = Date.now()
  return new Promise<number>(resolve => {
    setTimeout(() => resolve(Date.now() - start - 1), 1)
  })
}

// In production, use perf_hooks for precise measurement:
import { monitorEventLoopDelay } from 'node:perf_hooks'

const histogram = monitorEventLoopDelay({ resolution: 10 })
histogram.enable()

setInterval(() => {
  console.log({
    p50: histogram.percentile(50) / 1e6,  // nanoseconds → milliseconds
    p99: histogram.percentile(99) / 1e6,
    max: histogram.max / 1e6,
  })
  histogram.reset()
}, 5000)

// ❌ Infinite nextTick recursion — I/O callbacks NEVER run:
function recursiveNextTick() {
  process.nextTick(recursiveNextTick)
}
recursiveNextTick()
// The nextTick queue is drained completely before I/O runs.
// This loop never lets the event loop move past the microtask draining step.

// ✅ Use setImmediate for recursive async work — it yields to I/O between calls:
function recursiveImmediate() {
  setImmediate(recursiveImmediate)
}
// setImmediate fires in the check phase, after poll — other I/O runs between calls.

Node process
  ├─ V8 (JavaScript engine — runs your code, one thread)
  └─ libuv (async I/O library)
       ├─ Event loop (single thread — coordinates phases)
       ├─ I/O polling (epoll/kqueue/IOCP — OS-level async, no threads needed)
       └─ Thread pool (UV_THREADPOOL_SIZE, default: 4)
            Used for: fs operations, DNS lookups (getaddrinfo), crypto (some ops), zlib

UV_THREADPOOL_SIZE=8 node server.js   ← increase if you have many concurrent fs/crypto ops