> const p = new Promise((resolve) => setTimeout(() => resolve('ready'), 2000));
> p
Promise { <pending> }          // Before the 2 seconds

// ... you wait two seconds ...

> p
Promise { 'ready' }            // Settled now, with its value visible

> Promise.reject(new Error('failure'))
Promise { <rejected> Error: failure ... }

// src/lab/consume-promise.js
const fs = require('node:fs/promises');   // The promise-based version of fs

fs.readFile('data/events.json', 'utf8')
  .then((content) => {
    // Runs if the promise is FULFILLED. It receives the value.
    const catalog = JSON.parse(content);
    console.log(`Loaded ${catalog.length} events`);
  })
  .catch((error) => {
    // Runs if the promise is REJECTED at any earlier point.
    console.error(`Could not load the catalog: ${error.message}`);
  })
  .finally(() => {
    // ALWAYS runs, whether it went well or badly. No arguments.
    console.error('[catalog] load attempt finished');
  });

// CALLBACKS: each step inside the previous one.
findEvent(eventId, (error, event) => {
  if (error) return console.error(error.message);
  checkCapacity(sessionId, quantity, (error, session) => {
    if (error) return console.error(error.message);
    createOrder(userId, session, quantity, (error, order) => {
      if (error) return console.error(error.message);
      console.log(order.id);
    });
  });
});

// PROMISES: each step at the SAME level, with a single catch at the end.
findEvent(eventId)
  .then((event) => checkCapacity(sessionId, quantity))
  .then((session) => createOrder(userId, session, quantity))
  .then((order) => console.log(order.id))
  .catch((error) => console.error(error.message));

// WRONG: the chain does NOT wait for createOrder.
findEvent(eventId)
  .then((event) => {
    createOrder(userId, event, 2);   // Missing return
  })
  .then((order) => {
    console.log(order.id);   // TypeError: order is undefined
  });

// RIGHT
findEvent(eventId)
  .then((event) => {
    return createOrder(userId, event, 2);
  })
  .then((order) => {
    console.log(order.id);
  });

// RIGHT, in short form: an arrow without braces returns implicitly.
findEvent(eventId)
  .then((event) => createOrder(userId, event, 2))
  .then((order) => console.log(order.id));

// src/utils/sleep.js
// Returns a promise that fulfills after the given number of milliseconds.

function sleep(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
}

module.exports = { sleep };

console.log('Before');
sleep(1000).then(() => console.log('One second later'));

// Simulates the charge through the payment gateway.
function chargeOrder(order) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (order.totalCents > 20000) {
        const error = new Error(
          `Payment declined: ${(order.totalCents / 100).toFixed(2)} EUR exceeds the limit`
        );
        error.code = 'PAYMENT_DECLINED';
        reject(error);
        return;
      }
      resolve({ ...order, status: 'paid' });
    }, 40);
  });
}

// src/lab/promisify.js
const { promisify } = require('node:util');

// The functions from the previous lesson, with error-first callbacks.
// function findEvent(id, callback) { ... }
// function findSession(sessionId, callback) { ... }
// function reserveTickets(sessionId, quantity, callback) { ... }

const findEventP = promisify(findEvent);
const findSessionP = promisify(findSession);
const reserveTicketsP = promisify(reserveTickets);

// And now they are used as promises.
findEventP('evt-002')
  .then((event) => console.log(`Found: ${event.title}`))
  .catch((error) => console.error(`[${error.code}] ${error.message}`));

// A simplified version of what promisify does.
function promisifyManual(callbackFunction) {
  return function (...args) {
    return new Promise((resolve, reject) => {
      callbackFunction(...args, (error, result) => {
        if (error) {
          reject(error);
          return;
        }
        resolve(result);
      });
    });
  };
}

async function getTitle() {
  return 'Concierto de Otono';   // We return a string...
}

console.log(getTitle());               // Promise { 'Concierto de Otono' }
getTitle().then((t) => console.log(t)); // Concierto de Otono

async function fail() {
  throw new Error('something went wrong');
}

fail().catch((error) => console.error(error.message));   // something went wrong

// src/lab/await-does-not-block.js
const { sleep } = require('../utils/sleep.js');

async function slowTask() {
  console.log('  [slow] starting');
  await sleep(300);
  console.log('  [slow] finished');
}

// A heartbeat that shows the process is still alive.
const heartbeat = setInterval(() => console.log('heartbeat'), 100);

slowTask().then(() => clearInterval(heartbeat));

console.log('This line runs BEFORE slowTask finishes');

  [slow] starting
This line runs BEFORE slowTask finishes
heartbeat
heartbeat
  [slow] finished

// SyntaxError: await is only valid in async functions
function wrong() {
  const event = await findEventP('evt-001');
}

// src/lab/try-catch-works.js

async function showEvent(id) {
  try {
    const event = await findEventP(id);
    console.log(`Found: ${event.title}`);
  } catch (error) {
    // It IS caught. await turns the rejection into a normal exception.
    console.error(`[${error.code}] ${error.message}`);
  } finally {
    // And finally works too: cleanup goes here.
    console.error(`[query] finished for ${id}`);
  }
}

showEvent('evt-999');

[EVENT_NOT_FOUND] Event not found: evt-999
[query] finished for evt-999

function buyTickets(userId, eventId, sessionId, quantity, onDone) {
  const context = { userId, eventId, sessionId, quantity, capacityReserved: false };

  findEvent(eventId, onEventFound);

  function onEventFound(error, event) {
    if (error) return fail('find-event', error);
    context.event = event;
    reserveTickets(sessionId, quantity, onReserved);
  }
  function onReserved(error, reservation) { /* ... */ }
  function onSessionFound(error, result) { /* ... */ }
  function onOrderCreated(error, order) { /* ... */ }
  function onCharged(error, paidOrder) { /* ... */ }
  function onIssued(error, tickets) { /* ... */ }
  function fail(step, error) { /* ... */ }
  function compensateAndFail(step, error) {
    releaseCapacity(sessionId, quantity, (releaseError) => { /* ... */ });
  }
}

// src/lab/purchase-async.js
// The same purchase flow, with promises. 30 lines instead of 70.

async function buyTickets(userId, eventId, sessionId, quantity) {
  const event = await findEventP(eventId);

  // From here on there is reserved capacity that may have to be given back.
  const reservation = await reserveTicketsP(sessionId, quantity);

  try {
    const { session } = await findSessionP(sessionId);
    const order = await createOrderP(userId, session, quantity);
    const paidOrder = await chargeOrder(order);
    const tickets = await issueTicketsP(paidOrder);

    return { event, session, order: paidOrder, tickets };
  } catch (error) {
    // Compensation: we release the capacity we had reserved.
    const available = await releaseCapacityP(sessionId, quantity);
    console.error(`[compensation] capacity released in ${sessionId}, ${available} available`);

    // And we rethrow: our caller decides what to do.
    throw error;
  }
}

async function main() {
  try {
    const purchase = await buyTickets('att-001', 'evt-002', 'ses-002-2', 3);

    console.log(`Order ${purchase.order.id} - ${purchase.order.status}`);
    console.log(`  Event : ${purchase.event.title}`);
    console.log(`  Amount: ${(purchase.order.totalCents / 100).toFixed(2)} EUR`);
    for (const ticket of purchase.tickets) {
      console.log(`  ${ticket.code}  ${ticket.status}`);
    }
  } catch (error) {
    console.error(`[${error.code || 'ERROR'}] ${error.message}`);
    process.exitCode = 1;
  }
}

main();

// src/lab/sequential-vs-parallel.js
// WRONG: the three events are independent, but they load in series.

async function loadEventsInSeries(ids) {
  const events = [];
  for (const id of ids) {
    const event = await findEventP(id);   // Waits for the previous one to finish
    events.push(event);
  }
  return events;
}

const start = Date.now();
loadEventsInSeries(['evt-001', 'evt-002', 'evt-003']).then((events) => {
  console.log(`In series: ${events.length} events in ${Date.now() - start} ms`);
});

In series: 3 events in 124 ms

// RIGHT: the three requests go out at once.
async function loadEventsInParallel(ids) {
  // map returns an array of PROMISES: the three operations have already started.
  const promises = ids.map((id) => findEventP(id));

  // Promise.all waits for ALL of them to fulfill.
  return Promise.all(promises);
}

const start2 = Date.now();
loadEventsInParallel(['evt-001', 'evt-002', 'evt-003']).then((events) => {
  console.log(`In parallel: ${events.length} events in ${Date.now() - start2} ms`);
});

In parallel: 3 events in 42 ms

// src/utils/in-batches.js
// Runs a task over many items, at most N at a time.

async function inBatches(items, batchSize, task) {
  const results = [];

  for (let i = 0; i < items.length; i += batchSize) {
    const batch = items.slice(i, i + batchSize);
    // Within a batch, in parallel. Between batches, in series.
    const batchResults = await Promise.all(batch.map(task));
    results.push(...batchResults);
  }

  return results;
}

module.exports = { inBatches };

// Query 3000 sessions, 20 at a time.
const occupancies = await inBatches(sessionIds, 20, (id) => queryOccupancy(id));

const [almendra, boveda, ribera] = await Promise.all([
  findEventP('evt-001'),
  findEventP('evt-002'),
  findEventP('evt-003')
]);

try {
  const events = await Promise.all([
    findEventP('evt-001'),
    findEventP('evt-999'),   // Does not exist: it rejects
    findEventP('evt-003')
  ]);
} catch (error) {
  console.error(error.message);   // Event not found: evt-999
  // And we know nothing about evt-001 and evt-003, although they probably went fine.
}

// src/lab/resilient-report.js
// A report that must not fall over because one event fails.

const results = await Promise.allSettled([
  findEventP('evt-001'),
  findEventP('evt-999'),
  findEventP('evt-003')
]);

const found = [];
const failed = [];

for (const result of results) {
  if (result.status === 'fulfilled') {
    found.push(result.value.title);
  } else {
    failed.push(result.reason.message);
  }
}

console.log(`Found (${found.length}): ${found.join(', ')}`);
console.error(`Failed (${failed.length}): ${failed.join(' | ')}`);

Found (2): Concierto de Otono, Festival de Jazz de Primavera
Failed (1): Event not found: evt-999

// Timeout: either the gateway answers, or it rejects after 3 seconds.
const paidOrder = await Promise.race([
  chargeOrder(order),
  rejectAfter(3000, 'The payment gateway is not responding')
]);

// Query the price from three providers; the first good answer will do.
try {
  const exchangeRate = await Promise.any([
    queryProviderA(),
    queryProviderB(),
    queryProviderC()
  ]);
  console.log(`Exchange rate obtained: ${exchangeRate}`);
} catch (error) {
  // AggregateError: it contains ALL the errors in error.errors
  console.error(`No provider responded (${error.errors.length} failures)`);
  for (const failure of error.errors) {
    console.error(`  - ${failure.message}`);
  }
}

async function level3() {
  throw new Error('failure at the deepest level');
}

async function level2() {
  await level3();          // The rejection propagates upwards
  console.log('This does not run');
}

async function level1() {
  try {
    await level2();
  } catch (error) {
    console.error(`Caught in level1: ${error.message}`);
  }
}

level1();   // Caught in level1: failure at the deepest level

// src/lab/unhandled-rejection.js

async function charge() {
  throw new Error('The gateway returned a 500 error');
}

charge();   // Called, result ignored. NOBODY catches the rejection.

console.log('The script carries on...');

The script carries on...

node:internal/process/promises:288
            triggerUncaughtException(err, true /* fromPromise */);
            ^
Error: The gateway returned a 500 error
    ...
[the process dies with code 1]

// 1. Calling an async function without await and without .catch
processOrder(order);                     // WRONG
await processOrder(order);               // RIGHT
processOrder(order).catch(logError);     // RIGHT, if you don't want to wait

// 2. Forgetting the catch in a chain
findEventP(id).then((e) => console.log(e.title));            // WRONG
findEventP(id).then((e) => console.log(e.title)).catch(log); // RIGHT

// 3. The main function left unprotected
async function main() { /* ... */ }
main();                                        // WRONG
main().catch((error) => {                      // RIGHT
  console.error(`Fatal failure: ${error.message}`);
  process.exitCode = 1;
});

// src/utils/safety-net.js
// Logs any unhandled rejection before the process dies.

process.on('unhandledRejection', (reason, promise) => {
  console.error('UNHANDLED REJECTION. This is a programming error.');
  console.error(reason instanceof Error ? reason.stack : reason);
  process.exitCode = 1;
});

// src/lab/load.mjs   (note the .mjs extension)
import { readFile } from 'node:fs/promises';

// await directly, without wrapping it in any function.
const content = await readFile('data/events.json', 'utf8');
const catalog = JSON.parse(content);

console.log(`Loaded ${catalog.length} events`);

// src/utils/sleep.js
function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

module.exports = { sleep };

const { setTimeout: sleep } = require('node:timers/promises');

await sleep(1000);
console.log('One second later');

// src/utils/retry.js
// Retries an asynchronous operation with exponential backoff.

const { setTimeout: sleep } = require('node:timers/promises');

async function retry(operation, options = {}) {
  const {
    attempts = 3,
    initialDelayMs = 200,
    factor = 2,
    isRetryable = () => true
  } = options;

  let lastError;

  for (let attempt = 1; attempt <= attempts; attempt++) {
    try {
      return await operation(attempt);
    } catch (error) {
      lastError = error;

      // A business error is not retried: retrying an insufficient
      // capacity is not going to fix it.
      if (!isRetryable(error) || attempt === attempts) {
        throw error;
      }

      // Exponential backoff: 200, 400, 800 ms...
      const delay = initialDelayMs * factor ** (attempt - 1);
      console.error(
        `[retry] attempt ${attempt}/${attempts} failed (${error.message}). ` +
        `Retrying in ${delay} ms.`
      );
      await sleep(delay);
    }
  }

  throw lastError;
}

module.exports = { retry };

// Usage in Escena Viva: charging while retrying only network failures.
const RETRYABLE_CODES = new Set(['ETIMEDOUT', 'ECONNRESET', 'GATEWAY_UNAVAILABLE']);

const paidOrder = await retry(
  () => chargeOrder(order),
  {
    attempts: 4,
    initialDelayMs: 250,
    isRetryable: (error) => RETRYABLE_CODES.has(error.code)
  }
);

// src/utils/with-timeout.js
// Wraps a promise with a maximum waiting time.

function withTimeout(promise, limitMs, message = 'Waiting time exhausted') {
  let timer;

  const timeout = new Promise((_, reject) => {
    timer = setTimeout(() => {
      const error = new Error(`${message} (${limitMs} ms)`);
      error.code = 'TIMEOUT';
      reject(error);
    }, limitMs);
  });

  // The first one to settle wins.
  return Promise.race([promise, timeout]).finally(() => {
    // We clear the timer so it does not keep the process alive.
    clearTimeout(timer);
  });
}

module.exports = { withTimeout };

try {
  const paidOrder = await withTimeout(
    chargeOrder(order),
    3000,
    'The payment gateway is not responding'
  );
  console.log(`Charged: ${paidOrder.id}`);
} catch (error) {
  if (error.code === 'TIMEOUT') {
    console.error('Retry later or notify the user.');
  }
  throw error;
}

// It waits for NOTHING: forEach ignores the promises the callback returns.
ids.forEach(async (id) => { await process(id); });
console.log('Finished');   // A lie: nothing has finished

// Correct:
await Promise.all(ids.map((id) => process(id)));

// src/lab/catalog-promises.js
// Compares sequential, parallel and resilient loading of the catalog.

const { promisify } = require('node:util');

// findEvent comes from the previous lesson (error-first callback).
const findEventP = promisify(findEvent);

// 2. In series: each request waits for the previous one.
async function loadCatalogSeries(ids) {
  const events = [];
  for (const id of ids) {
    events.push(await findEventP(id));
  }
  return events;
}

// 3. In parallel: every request starts at once.
async function loadCatalogParallel(ids) {
  return Promise.all(ids.map((id) => findEventP(id)));
}

// 5. Resilient: partial failures do not invalidate the rest.
async function loadCatalogResilient(ids) {
  const results = await Promise.allSettled(ids.map((id) => findEventP(id)));

  const events = [];
  const failures = [];

  results.forEach((result, index) => {
    if (result.status === 'fulfilled') {
      events.push(result.value);
    } else {
      failures.push({ id: ids[index], reason: result.reason.message });
    }
  });

  for (const failure of failures) {
    console.error(`[catalog] could not load ${failure.id}: ${failure.reason}`);
  }

  return { events, failures };
}

// --- Measurement ---
async function measure(label, fn, ids) {
  const start = Date.now();
  const result = await fn(ids);
  const ms = Date.now() - start;
  const count = Array.isArray(result) ? result.length : result.events.length;
  return { label, events: count, ms };
}

async function main() {
  const ids = ['evt-001', 'evt-002', 'evt-003'];

  const series = await measure('series', loadCatalogSeries, ids);
  const parallel = await measure('parallel', loadCatalogParallel, ids);

  console.table([
    series,
    parallel,
    { label: 'speedup', events: '-', ms: `x${(series.ms / parallel.ms).toFixed(1)}` }
  ]);

  console.error('');
  console.error('--- Resilient variant with a non-existent id ---');
  const resilient = await loadCatalogResilient([...ids, 'evt-999']);
  console.log(
    `Resilient: ${resilient.events.length} loaded, ${resilient.failures.length} failed`
  );
}

main().catch((error) => {
  console.error(`Fatal failure: ${error.message}`);
  process.exitCode = 1;
});

┌─────────┬────────────┬────────┬────────┐
│ (index) │ label      │ events │ ms     │
├─────────┼────────────┼────────┼────────┤
│ 0       │ 'series'   │ 3      │ 124    │
│ 1       │ 'parallel' │ 3      │ 42     │
│ 2       │ 'speedup'  │ '-'    │ 'x3.0' │
└─────────┴────────────┴────────┴────────┘

--- Resilient variant with a non-existent id ---
[catalog] could not load evt-999: Event not found: evt-999
Resilient: 3 loaded, 1 failed

// src/lab/purchase-robust.js
// Purchase flow with a timeout, selective retries and compensation.

const { setTimeout: sleep } = require('node:timers/promises');

const RETRYABLE_CODES = new Set([
  'TIMEOUT', 'ETIMEDOUT', 'GATEWAY_UNAVAILABLE'
]);

// --- Utilities ---

function withTimeout(promise, limitMs, message = 'Waiting time exhausted') {
  let timer;
  const timeout = new Promise((_, reject) => {
    timer = setTimeout(() => {
      const error = new Error(`${message} (${limitMs} ms)`);
      error.code = 'TIMEOUT';
      reject(error);
    }, limitMs);
  });
  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
}

async function retry(operation, { attempts = 3, initialDelayMs = 200, factor = 2 } = {}) {
  for (let attempt = 1; attempt <= attempts; attempt++) {
    try {
      return await operation(attempt);
    } catch (error) {
      const retryable = RETRYABLE_CODES.has(error.code);

      if (!retryable) {
        console.error(`[retry] "${error.code}" is not retryable. Giving up.`);
        throw error;
      }
      if (attempt === attempts) {
        console.error(`[retry] all ${attempts} attempts exhausted.`);
        throw error;
      }

      const delay = initialDelayMs * factor ** (attempt - 1);
      console.error(
        `[retry] attempt ${attempt}/${attempts} failed (${error.message}). ` +
        `Retrying in ${delay} ms.`
      );
      await sleep(delay);
    }
  }
}

// --- Simulated gateway ---

let gatewayCalls = 0;

function chargeOrder(order) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      // Business error: NOT retryable.
      if (order.totalCents > 20000) {
        const error = new Error(
          `Payment declined: ${(order.totalCents / 100).toFixed(2)} EUR exceeds the limit`
        );
        error.code = 'PAYMENT_DECLINED';
        reject(error);
        return;
      }

      // Transient error: the first two calls fail.
      gatewayCalls++;
      if (gatewayCalls <= 2) {
        const error = new Error('The gateway is unavailable');
        error.code = 'GATEWAY_UNAVAILABLE';
        reject(error);
        return;
      }

      resolve({ ...order, status: 'paid' });
    }, 40);
  });
}

// --- Purchase flow ---

async function buyTickets(userId, eventId, sessionId, quantity) {
  const event = await findEventP(eventId);
  await reserveTicketsP(sessionId, quantity);

  try {
    const { session } = await findSessionP(sessionId);
    const order = await createOrderP(userId, session, quantity);

    // Retries on the outside, timeout on the inside: each attempt
    // gets its own 2 seconds.
    const paidOrder = await retry(
      () => withTimeout(chargeOrder(order), 2000, 'The gateway is not responding'),
      { attempts: 3, initialDelayMs: 200 }
    );

    const tickets = await issueTicketsP(paidOrder);
    return { event, session, order: paidOrder, tickets };
  } catch (error) {
    const available = await releaseCapacityP(sessionId, quantity);
    console.error(`[compensation] capacity released in ${sessionId}, ${available} available`);
    throw error;
  }
}

// --- Tests ---

async function main() {
  // Path 1: 3 x 18.00 = 54.00 EUR. Fails twice and works on the third try.
  console.error('--- Purchase that succeeds after two retries ---');
  const purchase = await buyTickets('att-001', 'evt-002', 'ses-002-2', 3);
  console.log(`Order ${purchase.order.id} - ${purchase.order.status}`);
  console.log(`  Amount: ${(purchase.order.totalCents / 100).toFixed(2)} EUR`);
  console.log(`  Tickets: ${purchase.tickets.map((t) => t.code).join(', ')}`);

  // Path 2: 5 x 42.00 = 210.00 EUR. Declined, not retryable.
  console.error('');
  console.error('--- Purchase declined without retries ---');
  try {
    await buyTickets('att-002', 'evt-003', 'ses-003-2', 5);
  } catch (error) {
    console.error(`Result: [${error.code}] ${error.message}`);
  }
}

main().catch((error) => {
  console.error(`Fatal failure: ${error.message}`);
  process.exitCode = 1;
});

--- Purchase that succeeds after two retries ---
[retry] attempt 1/3 failed (The gateway is unavailable). Retrying in 200 ms.
[retry] attempt 2/3 failed (The gateway is unavailable). Retrying in 400 ms.
Order ord-001 - paid
  Amount: 54.00 EUR
  Tickets: EV-2026-000001, EV-2026-000002, EV-2026-000003

--- Purchase declined without retries ---
[retry] "PAYMENT_DECLINED" is not retryable. Giving up.
[compensation] capacity released in ses-003-2, 180 available
Result: [PAYMENT_DECLINED] Payment declined: 210.00 EUR exceeds the limit

// src/lab/occupancy-dashboard.js
// Escena Viva occupancy dashboard with bounded parallelism and loop measurement.

const { monitorEventLoopDelay } = require('node:perf_hooks');

const VENUES = ['Teatro Almendra', 'Sala Boveda', 'Auditorio Ribera'];
const LATENCY_MS = 30;

// 1. Simulated query for one session.
function queryOccupancy(sessionId, index) {
  return new Promise((resolve) => {
    setTimeout(() => {
      const capacity = 420;
      const sold = (index * 37) % capacity;
      resolve({
        sessionId,
        venue: VENUES[index % VENUES.length],
        percentage: Math.round((sold / capacity) * 100),
        revenueCents: sold * 2500
      });
    }, LATENCY_MS);
  });
}

// 2. Bounded parallelism.
async function inBatches(items, batchSize, task) {
  const results = [];
  for (let i = 0; i < items.length; i += batchSize) {
    const batch = items.slice(i, i + batchSize);
    results.push(...await Promise.all(batch.map(task)));
  }
  return results;
}

async function generateDashboard(sessionIds, batchSize) {
  return inBatches(sessionIds, batchSize, (id, i) => queryOccupancy(id, i));
}

// 3. Aggregation by venue.
function aggregateByVenue(occupancies) {
  const byVenue = new Map();

  for (const o of occupancies) {
    const a = byVenue.get(o.venue) ?? { venue: o.venue, sessions: 0, percentageSum: 0, revenueCents: 0 };
    a.sessions++;
    a.percentageSum += o.percentage;
    a.revenueCents += o.revenueCents;
    byVenue.set(o.venue, a);
  }

  return [...byVenue.values()].map((a) => ({
    venue: a.venue,
    sessions: a.sessions,
    averageOccupancy: `${Math.round(a.percentageSum / a.sessions)}%`,
    revenueEuros: (a.revenueCents / 100).toFixed(2)
  }));
}

async function main() {
  const ids = Array.from({ length: 300 }, (_, i) => `ses-${String(i + 1).padStart(3, '0')}-1`);

  // 4. Measuring loop lag throughout the whole process.
  const histogram = monitorEventLoopDelay({ resolution: 5 });
  histogram.enable();

  // 5. Batch size comparison.
  const comparison = [];
  for (const batchSize of [1, 10, 50, 300]) {
    const start = Date.now();
    await generateDashboard(ids, batchSize);
    comparison.push({ batchSize, ms: Date.now() - start });
  }

  histogram.disable();

  const occupancies = await generateDashboard(ids, 50);

  console.log('OCCUPANCY DASHBOARD');
  console.table(aggregateByVenue(occupancies));

  console.log('');
  console.log('TIME BY BATCH SIZE');
  console.table(comparison);

  const toMs = (n) => (n / 1e6).toFixed(2);
  console.error('');
  console.error(`Loop lag: mean ${toMs(histogram.mean)} ms, p99 ${toMs(histogram.percentile(99))} ms`);
}

main().catch((error) => {
  console.error(`Fatal failure: ${error.message}`);
  process.exitCode = 1;
});

OCCUPANCY DASHBOARD
┌─────────┬────────────────────┬──────────┬──────────────────┬──────────────┐
│ (index) │ venue              │ sessions │ averageOccupancy │ revenueEuros │
├─────────┼────────────────────┼──────────┼──────────────────┼──────────────┤
│ 0       │ 'Teatro Almendra'  │ 100      │ '49%'            │ '515450.00'  │
│ 1       │ 'Sala Boveda'      │ 100      │ '50%'            │ '523900.00'  │
│ 2       │ 'Auditorio Ribera' │ 100      │ '50%'            │ '521100.00'  │
└─────────┴────────────────────┴──────────┴──────────────────┴──────────────┘

TIME BY BATCH SIZE
┌─────────┬───────────┬──────┐
│ (index) │ batchSize │ ms   │
├─────────┼───────────┼──────┤
│ 0       │ 1         │ 9412 │
│ 1       │ 10        │ 942  │
│ 2       │ 50        │ 192  │
│ 3       │ 300       │ 32   │
└─────────┴───────────┴──────┘

Loop lag: mean 5.31 ms, p99 11.08 ms