> const p = new Promise((resolve) => setTimeout(() => resolve('llest'), 2000));
> p
Promise { <pending> }          // Abans dels 2 segons

// ... esperes dos segons ...

> p
Promise { 'llest' }            // Ja assentada, i amb el seu valor visible

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

// src/laboratori/consumir-promesa.js
const fs = require('node:fs/promises');   // La versio amb promeses de fs

fs.readFile('dades/esdeveniments.json', 'utf8')
  .then((contingut) => {
    // S'executa si la promesa es COMPLEIX. Rep el valor.
    const cataleg = JSON.parse(contingut);
    console.log(`Carregats ${cataleg.length} esdeveniments`);
  })
  .catch((error) => {
    // S'executa si la promesa es REBUTJA en qualsevol punt anterior.
    console.error(`No s'ha pogut carregar el cataleg: ${error.message}`);
  })
  .finally(() => {
    // S'executa SEMPRE, tant si ha anat be com malament. Sense arguments.
    console.error('[cataleg] intent de carrega finalitzat');
  });

// CALLBACKS: cada pas dins de l'anterior.
cercarEsdeveniment(esdevenimentId, (error, esdeveniment) => {
  if (error) return console.error(error.message);
  comprovarAforament(sessioId, quantitat, (error, sessio) => {
    if (error) return console.error(error.message);
    crearComanda(usuariId, sessio, quantitat, (error, comanda) => {
      if (error) return console.error(error.message);
      console.log(comanda.id);
    });
  });
});

// PROMESES: cada pas al MATEIX nivell, amb un unic catch al final.
cercarEsdeveniment(esdevenimentId)
  .then((esdeveniment) => comprovarAforament(sessioId, quantitat))
  .then((sessio) => crearComanda(usuariId, sessio, quantitat))
  .then((comanda) => console.log(comanda.id))
  .catch((error) => console.error(error.message));

// MALAMENT: la cadena NO espera crearComanda.
cercarEsdeveniment(esdevenimentId)
  .then((esdeveniment) => {
    crearComanda(usuariId, esdeveniment, 2);   // Falta el return
  })
  .then((comanda) => {
    console.log(comanda.id);   // TypeError: comanda es undefined
  });

// BE
cercarEsdeveniment(esdevenimentId)
  .then((esdeveniment) => {
    return crearComanda(usuariId, esdeveniment, 2);
  })
  .then((comanda) => {
    console.log(comanda.id);
  });

// BE, en forma curta: la fletxa sense claus torna implicitament.
cercarEsdeveniment(esdevenimentId)
  .then((esdeveniment) => crearComanda(usuariId, esdeveniment, 2))
  .then((comanda) => console.log(comanda.id));

// src/utils/dormir.js
// Torna una promesa que es compleix passats els mil·lisegons indicats.

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

module.exports = { dormir };

console.log('Abans');
dormir(1000).then(() => console.log('Un segon despres'));

// Simula el cobrament amb la passarella de pagament.
function cobrarComanda(comanda) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (comanda.totalCentims > 20000) {
        const error = new Error(
          `Pagament rebutjat: ${(comanda.totalCentims / 100).toFixed(2)} EUR supera el limit`
        );
        error.codi = 'PAGAMENT_REBUTJAT';
        reject(error);
        return;
      }
      resolve({ ...comanda, estat: 'pagat' });
    }, 40);
  });
}

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

// Les funcions de la llico anterior, amb callback error-first.
// function cercarEsdeveniment(id, callback) { ... }
// function cercarSessio(sessioId, callback) { ... }
// function reservarEntrades(sessioId, quantitat, callback) { ... }

const cercarEsdevenimentP = promisify(cercarEsdeveniment);
const cercarSessioP = promisify(cercarSessio);
const reservarEntradesP = promisify(reservarEntrades);

// I ja es fan servir com a promeses.
cercarEsdevenimentP('evt-002')
  .then((esdeveniment) => console.log(`Trobat: ${esdeveniment.titol}`))
  .catch((error) => console.error(`[${error.codi}] ${error.message}`));

// Versio simplificada del que fa promisify.
function promisificar(funcioAmbCallback) {
  return function (...parametres) {
    return new Promise((resolve, reject) => {
      funcioAmbCallback(...parametres, (error, resultat) => {
        if (error) {
          reject(error);
          return;
        }
        resolve(resultat);
      });
    });
  };
}

async function obtenirTitol() {
  return 'Concierto de Otono';   // Tornem una cadena...
}

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

async function fallar() {
  throw new Error('alguna cosa ha anat malament');
}

fallar().catch((error) => console.error(error.message));   // alguna cosa ha anat malament

// src/laboratori/await-no-bloqueja.js
const { dormir } = require('../utils/dormir.js');

async function tascaLenta() {
  console.log('  [lenta] comenco');
  await dormir(300);
  console.log('  [lenta] acabo');
}

// Un batec que demostra que el proces continua viu.
const batec = setInterval(() => console.log('batec'), 100);

tascaLenta().then(() => clearInterval(batec));

console.log("Aquesta linia s'executa ABANS que tascaLenta acabi");

  [lenta] comenco
Aquesta linia s'executa ABANS que tascaLenta acabi
batec
batec
  [lenta] acabo

// SyntaxError: await is only valid in async functions
function malament() {
  const esdeveniment = await cercarEsdevenimentP('evt-001');
}

// src/laboratori/try-catch-funciona.js

async function mostrarEsdeveniment(id) {
  try {
    const esdeveniment = await cercarEsdevenimentP(id);
    console.log(`Trobat: ${esdeveniment.titol}`);
  } catch (error) {
    // SI que es captura. L'await converteix el rebuig en una excepcio normal.
    console.error(`[${error.codi}] ${error.message}`);
  } finally {
    // I finally tambe funciona: aqui va la neteja.
    console.error(`[consulta] acabada per a ${id}`);
  }
}

mostrarEsdeveniment('evt-999');

[ESDEVENIMENT_NO_TROBAT] Esdeveniment no trobat: evt-999
[consulta] acabada per a evt-999

function comprarEntrades(usuariId, esdevenimentId, sessioId, quantitat, enAcabar) {
  const context = { usuariId, esdevenimentId, sessioId, quantitat, aforamentReservat: false };

  cercarEsdeveniment(esdevenimentId, enTrobarEsdeveniment);

  function enTrobarEsdeveniment(error, esdeveniment) {
    if (error) return fallar('cercar-esdeveniment', error);
    context.esdeveniment = esdeveniment;
    reservarEntrades(sessioId, quantitat, enReservar);
  }
  function enReservar(error, reserva) { /* ... */ }
  function enCercarSessio(error, resultat) { /* ... */ }
  function enCrearComanda(error, comanda) { /* ... */ }
  function enCobrar(error, comandaPagada) { /* ... */ }
  function enEmetre(error, entrades) { /* ... */ }
  function fallar(pas, error) { /* ... */ }
  function compensarIFallar(pas, error) {
    alliberarAforament(sessioId, quantitat, (errorAlliberar) => { /* ... */ });
  }
}

// src/laboratori/compra-async.js
// El mateix flux de compra, amb promeses. 30 linies en lloc de 70.

async function comprarEntrades(usuariId, esdevenimentId, sessioId, quantitat) {
  const esdeveniment = await cercarEsdevenimentP(esdevenimentId);

  // A partir d'aqui hi ha aforament reservat que potser caldra tornar.
  const reserva = await reservarEntradesP(sessioId, quantitat);

  try {
    const { sessio } = await cercarSessioP(sessioId);
    const comanda = await crearComandaP(usuariId, sessio, quantitat);
    const comandaPagada = await cobrarComanda(comanda);
    const entrades = await emetreEntradesP(comandaPagada);

    return { esdeveniment, sessio, comanda: comandaPagada, entrades };
  } catch (error) {
    // Compensacio: alliberem l'aforament que haviem reservat.
    const lliures = await alliberarAforamentP(sessioId, quantitat);
    console.error(`[compensacio] aforament alliberat a ${sessioId}, en queden ${lliures} lliures`);

    // I el rellancem: qui ens ha cridat decideix que fer.
    throw error;
  }
}

async function principal() {
  try {
    const compra = await comprarEntrades('asis-001', 'evt-002', 'ses-002-2', 3);

    console.log(`Comanda ${compra.comanda.id} - ${compra.comanda.estat}`);
    console.log(`  Esdeveniment: ${compra.esdeveniment.titol}`);
    console.log(`  Import      : ${(compra.comanda.totalCentims / 100).toFixed(2)} EUR`);
    for (const entrada of compra.entrades) {
      console.log(`  ${entrada.codi}  ${entrada.estat}`);
    }
  } catch (error) {
    console.error(`[${error.codi || 'ERROR'}] ${error.message}`);
    process.exitCode = 1;
  }
}

principal();

// src/laboratori/sequencial-vs-parallel.js
// MALAMENT: els tres esdeveniments son independents, pero es carreguen en serie.

async function carregarEsdevenimentsEnSerie(ids) {
  const esdeveniments = [];
  for (const id of ids) {
    const esdeveniment = await cercarEsdevenimentP(id);   // Espera que acabi l'anterior
    esdeveniments.push(esdeveniment);
  }
  return esdeveniments;
}

const inici = Date.now();
carregarEsdevenimentsEnSerie(['evt-001', 'evt-002', 'evt-003']).then((esdeveniments) => {
  console.log(`En serie: ${esdeveniments.length} esdeveniments en ${Date.now() - inici} ms`);
});

En serie: 3 esdeveniments en 124 ms

// BE: les tres peticions surten alhora.
async function carregarEsdevenimentsEnParallel(ids) {
  // map torna un array de PROMESES: les tres operacions ja han comencat.
  const promeses = ids.map((id) => cercarEsdevenimentP(id));

  // Promise.all espera que TOTES es compleixin.
  return Promise.all(promeses);
}

const inici2 = Date.now();
carregarEsdevenimentsEnParallel(['evt-001', 'evt-002', 'evt-003']).then((esdeveniments) => {
  console.log(`En parallel: ${esdeveniments.length} esdeveniments en ${Date.now() - inici2} ms`);
});

En parallel: 3 esdeveniments en 42 ms

// src/utils/en-lots.js
// Executa una tasca sobre molts elements, com a maxim N alhora.

async function enLots(elements, midaLot, tasca) {
  const resultats = [];

  for (let i = 0; i < elements.length; i += midaLot) {
    const lot = elements.slice(i, i + midaLot);
    // Dins del lot, en parallel. Entre lots, en serie.
    const resultatsLot = await Promise.all(lot.map(tasca));
    resultats.push(...resultatsLot);
  }

  return resultats;
}

module.exports = { enLots };

// Consultar 3000 sessions de 20 en 20.
const ocupacions = await enLots(idsSessions, 20, (id) => consultarOcupacio(id));

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

try {
  const esdeveniments = await Promise.all([
    cercarEsdevenimentP('evt-001'),
    cercarEsdevenimentP('evt-999'),   // No existeix: es rebutja
    cercarEsdevenimentP('evt-003')
  ]);
} catch (error) {
  console.error(error.message);   // Esdeveniment no trobat: evt-999
  // I d'evt-001 i evt-003 no en sabem res, encara que probablement van anar be.
}

// src/laboratori/informe-resilient.js
// Un informe que no ha de caure perque falli un esdeveniment.

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

const trobats = [];
const fallits = [];

for (const resultat of resultats) {
  if (resultat.status === 'fulfilled') {
    trobats.push(resultat.value.titol);
  } else {
    fallits.push(resultat.reason.message);
  }
}

console.log(`Trobats (${trobats.length}): ${trobats.join(', ')}`);
console.error(`Fallits (${fallits.length}): ${fallits.join(' | ')}`);

Trobats (2): Concierto de Otono, Festival de Jazz de Primavera
Fallits (1): Esdeveniment no trobat: evt-999

// Temps limit: o respon la passarella, o es rebutja als 3 segons.
const comandaPagada = await Promise.race([
  cobrarComanda(comanda),
  rebutjarDespresDe(3000, 'La passarella de pagament no respon')
]);

// Consultar el preu a tres proveidors; ens val el primer que respongui be.
try {
  const tipusCanvi = await Promise.any([
    consultarProveidorA(),
    consultarProveidorB(),
    consultarProveidorC()
  ]);
  console.log(`Tipus de canvi obtingut: ${tipusCanvi}`);
} catch (error) {
  // AggregateError: conte TOTS els errors a error.errors
  console.error(`Cap proveidor no ha respost (${error.errors.length} fallades)`);
  for (const fallada of error.errors) {
    console.error(`  - ${fallada.message}`);
  }
}

async function nivell3() {
  throw new Error('fallada al nivell mes profund');
}

async function nivell2() {
  await nivell3();          // El rebuig es propaga cap amunt
  console.log("Aixo no s'executa");
}

async function nivell1() {
  try {
    await nivell2();
  } catch (error) {
    console.error(`Capturat a nivell1: ${error.message}`);
  }
}

nivell1();   // Capturat a nivell1: fallada al nivell mes profund

// src/laboratori/rebuig-no-gestionat.js

async function cobrar() {
  throw new Error('La passarella ha tornat un error 500');
}

cobrar();   // Es crida, s'ignora el resultat. NINGU no captura el rebuig.

console.log("L'script continua...");

L'script continua...

node:internal/process/promises:288
            triggerUncaughtException(err, true /* fromPromise */);
            ^
Error: La passarella ha tornat un error 500
    ...
[el proces mor amb codi 1]

// 1. Cridar una funcio async sense await ni .catch
processarComanda(comanda);                       // MALAMENT
await processarComanda(comanda);                 // BE
processarComanda(comanda).catch(registrarError); // BE, si no vols esperar

// 2. Oblidar el catch en una cadena
cercarEsdevenimentP(id).then((e) => console.log(e.titol));            // MALAMENT
cercarEsdevenimentP(id).then((e) => console.log(e.titol)).catch(log); // BE

// 3. La funcio principal sense protegir
async function principal() { /* ... */ }
principal();                                   // MALAMENT
principal().catch((error) => {                 // BE
  console.error(`Fallada fatal: ${error.message}`);
  process.exitCode = 1;
});

// src/utils/xarxa-de-seguretat.js
// Registra qualsevol rebuig no gestionat abans que el proces mori.

process.on('unhandledRejection', (motiu, promesa) => {
  console.error('REBUIG NO GESTIONAT. Aixo es una fallada de programacio.');
  console.error(motiu instanceof Error ? motiu.stack : motiu);
  process.exitCode = 1;
});

// src/laboratori/carrega.mjs   (fixa't en l'extensio .mjs)
import { readFile } from 'node:fs/promises';

// await directament, sense embolcallar-ho en cap funcio.
const contingut = await readFile('dades/esdeveniments.json', 'utf8');
const cataleg = JSON.parse(contingut);

console.log(`Carregats ${cataleg.length} esdeveniments`);

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

module.exports = { dormir };

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

await dormir(1000);
console.log('Un segon despres');

// src/utils/reintentar.js
// Reintenta una operacio asincrona amb espera exponencial.

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

async function reintentar(operacio, opcions = {}) {
  const {
    intents = 3,
    esperaInicialMs = 200,
    factor = 2,
    esReintentable = () => true
  } = opcions;

  let ultimError;

  for (let intent = 1; intent <= intents; intent++) {
    try {
      return await operacio(intent);
    } catch (error) {
      ultimError = error;

      // Un error de negoci no es reintenta: reintentar un aforament
      // insuficient no ho arreglara.
      if (!esReintentable(error) || intent === intents) {
        throw error;
      }

      // Espera exponencial: 200, 400, 800 ms...
      const espera = esperaInicialMs * factor ** (intent - 1);
      console.error(
        `[reintent] intent ${intent}/${intents} fallit (${error.message}). ` +
        `Es reintenta en ${espera} ms.`
      );
      await dormir(espera);
    }
  }

  throw ultimError;
}

module.exports = { reintentar };

// Us a Escena Viva: cobrar reintentant nomes les fallades de xarxa.
const CODIS_REINTENTABLES = new Set(['ETIMEDOUT', 'ECONNRESET', 'PASSARELLA_NO_DISPONIBLE']);

const comandaPagada = await reintentar(
  () => cobrarComanda(comanda),
  {
    intents: 4,
    esperaInicialMs: 250,
    esReintentable: (error) => CODIS_REINTENTABLES.has(error.codi)
  }
);

// src/utils/amb-limit-de-temps.js
// Embolcalla una promesa amb un temps maxim d'espera.

function ambLimitDeTemps(promesa, limitMs, missatge = "Temps d'espera exhaurit") {
  let temporitzador;

  const limit = new Promise((_, reject) => {
    temporitzador = setTimeout(() => {
      const error = new Error(`${missatge} (${limitMs} ms)`);
      error.codi = 'TEMPS_EXHAURIT';
      reject(error);
    }, limitMs);
  });

  // El primer que s'assenti guanya.
  return Promise.race([promesa, limit]).finally(() => {
    // Netegem el temporitzador per no retenir el proces viu.
    clearTimeout(temporitzador);
  });
}

module.exports = { ambLimitDeTemps };

try {
  const comandaPagada = await ambLimitDeTemps(
    cobrarComanda(comanda),
    3000,
    'La passarella de pagament no respon'
  );
  console.log(`Cobrada: ${comandaPagada.id}`);
} catch (error) {
  if (error.codi === 'TEMPS_EXHAURIT') {
    console.error("Reintentar mes tard o avisar l'usuari.");
  }
  throw error;
}

// NO espera res: forEach ignora les promeses que torna el callback.
ids.forEach(async (id) => { await processar(id); });
console.log('Acabat');   // Mentida: no ha acabat res

// Correcte:
await Promise.all(ids.map((id) => processar(id)));

// src/laboratori/cataleg-promeses.js
// Compara la carrega sequencial, parallela i resilient del cataleg.

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

// cercarEsdeveniment ve de la llico anterior (callback error-first).
const cercarEsdevenimentP = promisify(cercarEsdeveniment);

// 2. En serie: cada peticio espera l'anterior.
async function carregarCatalegSerie(ids) {
  const esdeveniments = [];
  for (const id of ids) {
    esdeveniments.push(await cercarEsdevenimentP(id));
  }
  return esdeveniments;
}

// 3. En parallel: totes les peticions arrenquen alhora.
async function carregarCatalegParallel(ids) {
  return Promise.all(ids.map((id) => cercarEsdevenimentP(id)));
}

// 5. Resilient: les fallades parcials no invaliden la resta.
async function carregarCatalegResilient(ids) {
  const resultats = await Promise.allSettled(ids.map((id) => cercarEsdevenimentP(id)));

  const esdeveniments = [];
  const fallades = [];

  resultats.forEach((resultat, index) => {
    if (resultat.status === 'fulfilled') {
      esdeveniments.push(resultat.value);
    } else {
      fallades.push({ id: ids[index], motiu: resultat.reason.message });
    }
  });

  for (const fallada of fallades) {
    console.error(`[cataleg] no s'ha pogut carregar ${fallada.id}: ${fallada.motiu}`);
  }

  return { esdeveniments, fallades };
}

// --- Mesura ---
async function mesurar(etiqueta, funcio, ids) {
  const inici = Date.now();
  const resultat = await funcio(ids);
  const ms = Date.now() - inici;
  const quants = Array.isArray(resultat) ? resultat.length : resultat.esdeveniments.length;
  return { etiqueta, esdeveniments: quants, ms };
}

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

  const serie = await mesurar('serie', carregarCatalegSerie, ids);
  const parallel = await mesurar('parallel', carregarCatalegParallel, ids);

  console.table([
    serie,
    parallel,
    { etiqueta: 'millora', esdeveniments: '-', ms: `x${(serie.ms / parallel.ms).toFixed(1)}` }
  ]);

  console.error('');
  console.error('--- Variant resilient amb un id inexistent ---');
  const resilient = await carregarCatalegResilient([...ids, 'evt-999']);
  console.log(
    `Resilient: ${resilient.esdeveniments.length} carregats, ${resilient.fallades.length} fallits`
  );
}

principal().catch((error) => {
  console.error(`Fallada fatal: ${error.message}`);
  process.exitCode = 1;
});

┌─────────┬────────────┬───────────────┬────────┐
│ (index) │ etiqueta   │ esdeveniments │ ms     │
├─────────┼────────────┼───────────────┼────────┤
│ 0       │ 'serie'    │ 3             │ 124    │
│ 1       │ 'parallel' │ 3             │ 42     │
│ 2       │ 'millora'  │ '-'           │ 'x3.0' │
└─────────┴────────────┴───────────────┴────────┘

--- Variant resilient amb un id inexistent ---
[cataleg] no s'ha pogut carregar evt-999: Esdeveniment no trobat: evt-999
Resilient: 3 carregats, 1 fallits

// src/laboratori/compra-robusta.js
// Flux de compra amb temps limit, reintents selectius i compensacio.

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

const CODIS_REINTENTABLES = new Set([
  'TEMPS_EXHAURIT', 'ETIMEDOUT', 'PASSARELLA_NO_DISPONIBLE'
]);

// --- Utilitats ---

function ambLimitDeTemps(promesa, limitMs, missatge = "Temps d'espera exhaurit") {
  let temporitzador;
  const limit = new Promise((_, reject) => {
    temporitzador = setTimeout(() => {
      const error = new Error(`${missatge} (${limitMs} ms)`);
      error.codi = 'TEMPS_EXHAURIT';
      reject(error);
    }, limitMs);
  });
  return Promise.race([promesa, limit]).finally(() => clearTimeout(temporitzador));
}

async function reintentar(operacio, { intents = 3, esperaInicialMs = 200, factor = 2 } = {}) {
  for (let intent = 1; intent <= intents; intent++) {
    try {
      return await operacio(intent);
    } catch (error) {
      const reintentable = CODIS_REINTENTABLES.has(error.codi);

      if (!reintentable) {
        console.error(`[reintent] "${error.codi}" no es reintentable. Ho deixo.`);
        throw error;
      }
      if (intent === intents) {
        console.error(`[reintent] exhaurits els ${intents} intents.`);
        throw error;
      }

      const espera = esperaInicialMs * factor ** (intent - 1);
      console.error(
        `[reintent] intent ${intent}/${intents} fallit (${error.message}). ` +
        `Reintent en ${espera} ms.`
      );
      await dormir(espera);
    }
  }
}

// --- Passarella simulada ---

let cridesAPassarella = 0;

function cobrarComanda(comanda) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      // Error de negoci: NO reintentable.
      if (comanda.totalCentims > 20000) {
        const error = new Error(
          `Pagament rebutjat: ${(comanda.totalCentims / 100).toFixed(2)} EUR supera el limit`
        );
        error.codi = 'PAGAMENT_REBUTJAT';
        reject(error);
        return;
      }

      // Error transitori: les dues primeres crides fallen.
      cridesAPassarella++;
      if (cridesAPassarella <= 2) {
        const error = new Error('La passarella no esta disponible');
        error.codi = 'PASSARELLA_NO_DISPONIBLE';
        reject(error);
        return;
      }

      resolve({ ...comanda, estat: 'pagat' });
    }, 40);
  });
}

// --- Flux de compra ---

async function comprarEntrades(usuariId, esdevenimentId, sessioId, quantitat) {
  const esdeveniment = await cercarEsdevenimentP(esdevenimentId);
  await reservarEntradesP(sessioId, quantitat);

  try {
    const { sessio } = await cercarSessioP(sessioId);
    const comanda = await crearComandaP(usuariId, sessio, quantitat);

    // Reintents per fora, temps limit per dins: cada intent
    // te els seus propis 2 segons.
    const comandaPagada = await reintentar(
      () => ambLimitDeTemps(cobrarComanda(comanda), 2000, 'La passarella no respon'),
      { intents: 3, esperaInicialMs: 200 }
    );

    const entrades = await emetreEntradesP(comandaPagada);
    return { esdeveniment, sessio, comanda: comandaPagada, entrades };
  } catch (error) {
    const lliures = await alliberarAforamentP(sessioId, quantitat);
    console.error(`[compensacio] aforament alliberat a ${sessioId}, en queden ${lliures} lliures`);
    throw error;
  }
}

// --- Proves ---

async function principal() {
  // Cami 1: 3 x 18,00 = 54,00 EUR. Falla dues vegades i funciona a la tercera.
  console.error('--- Compra que acaba funcionant despres de dos reintents ---');
  const compra = await comprarEntrades('asis-001', 'evt-002', 'ses-002-2', 3);
  console.log(`Comanda ${compra.comanda.id} - ${compra.comanda.estat}`);
  console.log(`  Import  : ${(compra.comanda.totalCentims / 100).toFixed(2)} EUR`);
  console.log(`  Entrades: ${compra.entrades.map((e) => e.codi).join(', ')}`);

  // Cami 2: 5 x 42,00 = 210,00 EUR. Rebuig no reintentable.
  console.error('');
  console.error('--- Compra rebutjada sense reintents ---');
  try {
    await comprarEntrades('asis-002', 'evt-003', 'ses-003-2', 5);
  } catch (error) {
    console.error(`Resultat: [${error.codi}] ${error.message}`);
  }
}

principal().catch((error) => {
  console.error(`Fallada fatal: ${error.message}`);
  process.exitCode = 1;
});

--- Compra que acaba funcionant despres de dos reintents ---
[reintent] intent 1/3 fallit (La passarella no esta disponible). Reintent en 200 ms.
[reintent] intent 2/3 fallit (La passarella no esta disponible). Reintent en 400 ms.
Comanda com-001 - pagat
  Import  : 54.00 EUR
  Entrades: EV-2026-000001, EV-2026-000002, EV-2026-000003

--- Compra rebutjada sense reintents ---
[reintent] "PAGAMENT_REBUTJAT" no es reintentable. Ho deixo.
[compensacio] aforament alliberat a ses-003-2, en queden 180 lliures
Resultat: [PAGAMENT_REBUTJAT] Pagament rebutjat: 210.00 EUR supera el limit

// src/laboratori/panell-ocupacio.js
// Panell d'ocupacio d'Escena Viva amb parallelisme acotat i mesura del bucle.

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

const SALES = ['Teatro Almendra', 'Sala Boveda', 'Auditorio Ribera'];
const LATENCIA_MS = 30;

// 1. Consulta simulada d'una sessio.
function consultarOcupacio(sessioId, index) {
  return new Promise((resolve) => {
    setTimeout(() => {
      const aforament = 420;
      const venudes = (index * 37) % aforament;
      resolve({
        sessioId,
        sala: SALES[index % SALES.length],
        percentatge: Math.round((venudes / aforament) * 100),
        recaptacioCentims: venudes * 2500
      });
    }, LATENCIA_MS);
  });
}

// 2. Parallelisme acotat.
async function enLots(elements, midaLot, tasca) {
  const resultats = [];
  for (let i = 0; i < elements.length; i += midaLot) {
    const lot = elements.slice(i, i + midaLot);
    resultats.push(...await Promise.all(lot.map(tasca)));
  }
  return resultats;
}

async function generarPanell(idsSessions, midaLot) {
  return enLots(idsSessions, midaLot, (id, i) => consultarOcupacio(id, i));
}

// 3. Agregacio per sala.
function agregarPerSala(ocupacions) {
  const perSala = new Map();

  for (const o of ocupacions) {
    const a = perSala.get(o.sala) ?? { sala: o.sala, sessions: 0, sumaPercentatges: 0, recaptacioCentims: 0 };
    a.sessions++;
    a.sumaPercentatges += o.percentatge;
    a.recaptacioCentims += o.recaptacioCentims;
    perSala.set(o.sala, a);
  }

  return [...perSala.values()].map((a) => ({
    sala: a.sala,
    sessions: a.sessions,
    ocupacioMitjana: `${Math.round(a.sumaPercentatges / a.sessions)}%`,
    recaptacioEuros: (a.recaptacioCentims / 100).toFixed(2)
  }));
}

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

  // 4. Mesura del retard del bucle durant tot el proces.
  const histograma = monitorEventLoopDelay({ resolution: 5 });
  histograma.enable();

  // 5. Comparativa de mides de lot.
  const comparativa = [];
  for (const midaLot of [1, 10, 50, 300]) {
    const inici = Date.now();
    await generarPanell(ids, midaLot);
    comparativa.push({ midaLot, ms: Date.now() - inici });
  }

  histograma.disable();

  const ocupacions = await generarPanell(ids, 50);

  console.log("PANELL D'OCUPACIO");
  console.table(agregarPerSala(ocupacions));

  console.log('');
  console.log('TEMPS SEGONS LA MIDA DE LOT');
  console.table(comparativa);

  const aMs = (n) => (n / 1e6).toFixed(2);
  console.error('');
  console.error(`Retard del bucle: mitjana ${aMs(histograma.mean)} ms, p99 ${aMs(histograma.percentile(99))} ms`);
}

principal().catch((error) => {
  console.error(`Fallada fatal: ${error.message}`);
  process.exitCode = 1;
});

PANELL D'OCUPACIO
┌─────────┬────────────────────┬──────────┬─────────────────┬─────────────────┐
│ (index) │ sala               │ sessions │ ocupacioMitjana │ recaptacioEuros │
├─────────┼────────────────────┼──────────┼─────────────────┼─────────────────┤
│ 0       │ 'Teatro Almendra'  │ 100      │ '49%'           │ '515450.00'     │
│ 1       │ 'Sala Boveda'      │ 100      │ '50%'           │ '523900.00'     │
│ 2       │ 'Auditorio Ribera' │ 100      │ '50%'           │ '521100.00'     │
└─────────┴────────────────────┴──────────┴─────────────────┴─────────────────┘

TEMPS SEGONS LA MIDA DE LOT
┌─────────┬─────────┬──────┐
│ (index) │ midaLot │ ms   │
├─────────┼─────────┼──────┤
│ 0       │ 1       │ 9412 │
│ 1       │ 10      │ 942  │
│ 2       │ 50      │ 192  │
│ 3       │ 300     │ 32   │
└─────────┴─────────┴──────┘

Retard del bucle: mitjana 5.31 ms, p99 11.08 ms