JavaScript Sleep: Await a Delay Without Blocking the Thread

The task

Collect an ordering trace around a short delay. The assertions check which events happen first, not that the machine wakes at an exact millisecond. The timer is bounded and the process exits after completion.

Runnable Node 22 example

const assert = require('node:assert/strict');

const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
const trace = [];
async function run() {
  trace.push('before');
  await sleep(5);
  trace.push('after');
}
const pending = run();
trace.push('caller continues');
assert.deepEqual(trace, ['before', 'caller continues']);
pending.then(() => {
  assert.deepEqual(trace, ['before', 'caller continues', 'after']);
  console.log(trace.join(' -> '));
}).catch(error => { console.error(error); process.exitCode = 1; });

Expected output and explanation

run begins synchronously and reaches its await. The caller can append its own trace entry while the timer is pending. After the delay resolves, execution resumes in run and appends the final entry. Await pauses this async continuation; it does not freeze all JavaScript activity.

An empty busy loop waiting for the clock would behave differently: it occupies the thread and prevents other scheduled callbacks from progressing. This example uses a timer-backed Promise so the waiting work yields instead.

Pitfall to check

Node timers do not promise execution at an exact time. Other work can delay the continuation, so use the delay as scheduling intent rather than a precision stopwatch. Ensure a rejected async task reaches a handler, as this script does.