> const p = new Promise((resolve) => setTimeout(() => resolve('listo'), 2000));
> p
Promise { <pending> }          // Antes de los 2 segundos

// ... esperas dos segundos ...

> p
Promise { 'listo' }            // Ya asentada, y con su valor visible

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

// src/laboratorio/consumir-promesa.js
const fs = require('node:fs/promises');   // La version con promesas de fs

fs.readFile('datos/eventos.json', 'utf8')
  .then((contenido) => {
    // Se ejecuta si la promesa se CUMPLE. Recibe el valor.
    const catalogo = JSON.parse(contenido);
    console.log(`Cargados ${catalogo.length} eventos`);
  })
  .catch((error) => {
    // Se ejecuta si la promesa se RECHAZA en cualquier punto anterior.
    console.error(`No se pudo cargar el catalogo: ${error.message}`);
  })
  .finally(() => {
    // Se ejecuta SIEMPRE, haya ido bien o mal. Sin argumentos.
    console.error('[catalogo] intento de carga finalizado');
  });

// CALLBACKS: cada paso dentro del anterior.
buscarEvento(eventoId, (error, evento) => {
  if (error) return console.error(error.message);
  comprobarAforo(sesionId, cantidad, (error, sesion) => {
    if (error) return console.error(error.message);
    crearPedido(usuarioId, sesion, cantidad, (error, pedido) => {
      if (error) return console.error(error.message);
      console.log(pedido.id);
    });
  });
});

// PROMESAS: cada paso al MISMO nivel, con un unico catch al final.
buscarEvento(eventoId)
  .then((evento) => comprobarAforo(sesionId, cantidad))
  .then((sesion) => crearPedido(usuarioId, sesion, cantidad))
  .then((pedido) => console.log(pedido.id))
  .catch((error) => console.error(error.message));

// MAL: la cadena NO espera a crearPedido.
buscarEvento(eventoId)
  .then((evento) => {
    crearPedido(usuarioId, evento, 2);   // Falta el return
  })
  .then((pedido) => {
    console.log(pedido.id);   // TypeError: pedido es undefined
  });

// BIEN
buscarEvento(eventoId)
  .then((evento) => {
    return crearPedido(usuarioId, evento, 2);
  })
  .then((pedido) => {
    console.log(pedido.id);
  });

// BIEN, en forma corta: la flecha sin llaves devuelve implicitamente.
buscarEvento(eventoId)
  .then((evento) => crearPedido(usuarioId, evento, 2))
  .then((pedido) => console.log(pedido.id));

// src/utiles/dormir.js
// Devuelve una promesa que se cumple pasados los milisegundos indicados.

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

module.exports = { dormir };

console.log('Antes');
dormir(1000).then(() => console.log('Un segundo despues'));

// Simula el cobro con la pasarela de pago.
function cobrarPedido(pedido) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (pedido.totalCentimos > 20000) {
        const error = new Error(
          `Pago rechazado: ${(pedido.totalCentimos / 100).toFixed(2)} EUR supera el limite`
        );
        error.codigo = 'PAGO_RECHAZADO';
        reject(error);
        return;
      }
      resolve({ ...pedido, estado: 'pagado' });
    }, 40);
  });
}

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

// Las funciones de la leccion anterior, con callback error-first.
// function buscarEvento(id, callback) { ... }
// function buscarSesion(sesionId, callback) { ... }
// function reservarEntradas(sesionId, cantidad, callback) { ... }

const buscarEventoP = promisify(buscarEvento);
const buscarSesionP = promisify(buscarSesion);
const reservarEntradasP = promisify(reservarEntradas);

// Y ya se usan como promesas.
buscarEventoP('evt-002')
  .then((evento) => console.log(`Encontrado: ${evento.titulo}`))
  .catch((error) => console.error(`[${error.codigo}] ${error.message}`));

// Version simplificada de lo que hace promisify.
function promisificar(funcionConCallback) {
  return function (...argumentos) {
    return new Promise((resolve, reject) => {
      funcionConCallback(...argumentos, (error, resultado) => {
        if (error) {
          reject(error);
          return;
        }
        resolve(resultado);
      });
    });
  };
}

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

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

async function fallar() {
  throw new Error('algo salio mal');
}

fallar().catch((error) => console.error(error.message));   // algo salio mal

// src/laboratorio/await-no-bloquea.js
const { dormir } = require('../utiles/dormir.js');

async function tareaLenta() {
  console.log('  [lenta] empiezo');
  await dormir(300);
  console.log('  [lenta] termino');
}

// Un latido que demuestra que el proceso sigue vivo.
const latido = setInterval(() => console.log('latido'), 100);

tareaLenta().then(() => clearInterval(latido));

console.log('Esta linea se ejecuta ANTES de que tareaLenta termine');

  [lenta] empiezo
Esta linea se ejecuta ANTES de que tareaLenta termine
latido
latido
  [lenta] termino

// SyntaxError: await is only valid in async functions
function mal() {
  const evento = await buscarEventoP('evt-001');
}

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

async function mostrarEvento(id) {
  try {
    const evento = await buscarEventoP(id);
    console.log(`Encontrado: ${evento.titulo}`);
  } catch (error) {
    // SI se captura. El await convierte el rechazo en una excepcion normal.
    console.error(`[${error.codigo}] ${error.message}`);
  } finally {
    // Y finally tambien funciona: aqui va la limpieza.
    console.error(`[consulta] terminada para ${id}`);
  }
}

mostrarEvento('evt-999');

[EVENTO_NO_ENCONTRADO] Evento no encontrado: evt-999
[consulta] terminada para evt-999

function comprarEntradas(usuarioId, eventoId, sesionId, cantidad, alTerminar) {
  const contexto = { usuarioId, eventoId, sesionId, cantidad, aforoReservado: false };

  buscarEvento(eventoId, alEncontrarEvento);

  function alEncontrarEvento(error, evento) {
    if (error) return fallo('buscar-evento', error);
    contexto.evento = evento;
    reservarEntradas(sesionId, cantidad, alReservar);
  }
  function alReservar(error, reserva) { /* ... */ }
  function alBuscarSesion(error, resultado) { /* ... */ }
  function alCrearPedido(error, pedido) { /* ... */ }
  function alCobrar(error, pedidoPagado) { /* ... */ }
  function alEmitir(error, entradas) { /* ... */ }
  function fallo(paso, error) { /* ... */ }
  function compensarYFallar(paso, error) {
    liberarAforo(sesionId, cantidad, (errorLiberar) => { /* ... */ });
  }
}

// src/laboratorio/compra-async.js
// El mismo flujo de compra, con promesas. 30 lineas en lugar de 70.

async function comprarEntradas(usuarioId, eventoId, sesionId, cantidad) {
  const evento = await buscarEventoP(eventoId);

  // A partir de aqui hay aforo reservado que puede haber que devolver.
  const reserva = await reservarEntradasP(sesionId, cantidad);

  try {
    const { sesion } = await buscarSesionP(sesionId);
    const pedido = await crearPedidoP(usuarioId, sesion, cantidad);
    const pedidoPagado = await cobrarPedido(pedido);
    const entradas = await emitirEntradasP(pedidoPagado);

    return { evento, sesion, pedido: pedidoPagado, entradas };
  } catch (error) {
    // Compensacion: liberamos el aforo que habiamos reservado.
    const libres = await liberarAforoP(sesionId, cantidad);
    console.error(`[compensacion] aforo liberado en ${sesionId}, quedan ${libres} libres`);

    // Y relanzamos: quien nos llamo decide que hacer.
    throw error;
  }
}

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

    console.log(`Pedido ${compra.pedido.id} - ${compra.pedido.estado}`);
    console.log(`  Evento : ${compra.evento.titulo}`);
    console.log(`  Importe: ${(compra.pedido.totalCentimos / 100).toFixed(2)} EUR`);
    for (const entrada of compra.entradas) {
      console.log(`  ${entrada.codigo}  ${entrada.estado}`);
    }
  } catch (error) {
    console.error(`[${error.codigo || 'ERROR'}] ${error.message}`);
    process.exitCode = 1;
  }
}

principal();

// src/laboratorio/secuencial-vs-paralelo.js
// MAL: los tres eventos son independientes, pero se cargan en serie.

async function cargarEventosEnSerie(ids) {
  const eventos = [];
  for (const id of ids) {
    const evento = await buscarEventoP(id);   // Espera a que termine el anterior
    eventos.push(evento);
  }
  return eventos;
}

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

En serie: 3 eventos en 124 ms

// BIEN: las tres peticiones salen a la vez.
async function cargarEventosEnParalelo(ids) {
  // map devuelve un array de PROMESAS: las tres operaciones ya han empezado.
  const promesas = ids.map((id) => buscarEventoP(id));

  // Promise.all espera a que TODAS se cumplan.
  return Promise.all(promesas);
}

const inicio2 = Date.now();
cargarEventosEnParalelo(['evt-001', 'evt-002', 'evt-003']).then((eventos) => {
  console.log(`En paralelo: ${eventos.length} eventos en ${Date.now() - inicio2} ms`);
});

En paralelo: 3 eventos en 42 ms

// src/utiles/en-lotes.js
// Ejecuta una tarea sobre muchos elementos, como maximo N a la vez.

async function enLotes(elementos, tamanoLote, tarea) {
  const resultados = [];

  for (let i = 0; i < elementos.length; i += tamanoLote) {
    const lote = elementos.slice(i, i + tamanoLote);
    // Dentro del lote, en paralelo. Entre lotes, en serie.
    const resultadosLote = await Promise.all(lote.map(tarea));
    resultados.push(...resultadosLote);
  }

  return resultados;
}

module.exports = { enLotes };

// Consultar 3000 sesiones de 20 en 20.
const ocupaciones = await enLotes(idsSesiones, 20, (id) => consultarOcupacion(id));

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

try {
  const eventos = await Promise.all([
    buscarEventoP('evt-001'),
    buscarEventoP('evt-999'),   // No existe: se rechaza
    buscarEventoP('evt-003')
  ]);
} catch (error) {
  console.error(error.message);   // Evento no encontrado: evt-999
  // Y de evt-001 y evt-003 no sabemos nada, aunque probablemente fueron bien.
}

// src/laboratorio/informe-resiliente.js
// Un informe que no debe caerse porque falle un evento.

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

const encontrados = [];
const fallidos = [];

for (const resultado of resultados) {
  if (resultado.status === 'fulfilled') {
    encontrados.push(resultado.value.titulo);
  } else {
    fallidos.push(resultado.reason.message);
  }
}

console.log(`Encontrados (${encontrados.length}): ${encontrados.join(', ')}`);
console.error(`Fallidos (${fallidos.length}): ${fallidos.join(' | ')}`);

Encontrados (2): Concierto de Otono, Festival de Jazz de Primavera
Fallidos (1): Evento no encontrado: evt-999

// Tiempo limite: o responde la pasarela, o se rechaza a los 3 segundos.
const pedidoPagado = await Promise.race([
  cobrarPedido(pedido),
  rechazarTras(3000, 'La pasarela de pago no responde')
]);

// Consultar el precio a tres proveedores; nos vale el primero que responda bien.
try {
  const tipoCambio = await Promise.any([
    consultarProveedorA(),
    consultarProveedorB(),
    consultarProveedorC()
  ]);
  console.log(`Tipo de cambio obtenido: ${tipoCambio}`);
} catch (error) {
  // AggregateError: contiene TODOS los errores en error.errors
  console.error(`Ningun proveedor respondio (${error.errors.length} fallos)`);
  for (const fallo of error.errors) {
    console.error(`  - ${fallo.message}`);
  }
}

async function nivel3() {
  throw new Error('fallo en el nivel mas profundo');
}

async function nivel2() {
  await nivel3();          // El rechazo se propaga hacia arriba
  console.log('Esto no se ejecuta');
}

async function nivel1() {
  try {
    await nivel2();
  } catch (error) {
    console.error(`Capturado en nivel1: ${error.message}`);
  }
}

nivel1();   // Capturado en nivel1: fallo en el nivel mas profundo

// src/laboratorio/rechazo-no-manejado.js

async function cobrar() {
  throw new Error('La pasarela devolvio un error 500');
}

cobrar();   // Se llama, se ignora el resultado. NADIE captura el rechazo.

console.log('El script continua...');

El script continua...

node:internal/process/promises:288
            triggerUncaughtException(err, true /* fromPromise */);
            ^
Error: La pasarela devolvio un error 500
    ...
[el proceso muere con codigo 1]

// 1. Llamar a una funcion async sin await ni .catch
procesarPedido(pedido);                       // MAL
await procesarPedido(pedido);                 // BIEN
procesarPedido(pedido).catch(registrarError); // BIEN, si no quieres esperar

// 2. Olvidar el catch en una cadena
buscarEventoP(id).then((e) => console.log(e.titulo));            // MAL
buscarEventoP(id).then((e) => console.log(e.titulo)).catch(log); // BIEN

// 3. La funcion principal sin proteger
async function principal() { /* ... */ }
principal();                                   // MAL
principal().catch((error) => {                 // BIEN
  console.error(`Fallo fatal: ${error.message}`);
  process.exitCode = 1;
});

// src/utiles/red-de-seguridad.js
// Registra cualquier rechazo no manejado antes de que el proceso muera.

process.on('unhandledRejection', (motivo, promesa) => {
  console.error('RECHAZO NO MANEJADO. Esto es un fallo de programacion.');
  console.error(motivo instanceof Error ? motivo.stack : motivo);
  process.exitCode = 1;
});

// src/laboratorio/carga.mjs   (fijate en la extension .mjs)
import { readFile } from 'node:fs/promises';

// await directamente, sin envolver en ninguna funcion.
const contenido = await readFile('datos/eventos.json', 'utf8');
const catalogo = JSON.parse(contenido);

console.log(`Cargados ${catalogo.length} eventos`);

// src/utiles/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 segundo despues');

// src/utiles/reintentar.js
// Reintenta una operacion asincrona con espera exponencial.

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

async function reintentar(operacion, opciones = {}) {
  const {
    intentos = 3,
    esperaInicialMs = 200,
    factor = 2,
    esReintentable = () => true
  } = opciones;

  let ultimoError;

  for (let intento = 1; intento <= intentos; intento++) {
    try {
      return await operacion(intento);
    } catch (error) {
      ultimoError = error;

      // Un error de negocio no se reintenta: reintentar un aforo
      // insuficiente no lo va a arreglar.
      if (!esReintentable(error) || intento === intentos) {
        throw error;
      }

      // Espera exponencial: 200, 400, 800 ms...
      const espera = esperaInicialMs * factor ** (intento - 1);
      console.error(
        `[reintento] intento ${intento}/${intentos} fallido (${error.message}). ` +
        `Reintentando en ${espera} ms.`
      );
      await dormir(espera);
    }
  }

  throw ultimoError;
}

module.exports = { reintentar };

// Uso en Escena Viva: cobrar reintentando solo los fallos de red.
const CODIGOS_REINTENTABLES = new Set(['ETIMEDOUT', 'ECONNRESET', 'PASARELA_NO_DISPONIBLE']);

const pedidoPagado = await reintentar(
  () => cobrarPedido(pedido),
  {
    intentos: 4,
    esperaInicialMs: 250,
    esReintentable: (error) => CODIGOS_REINTENTABLES.has(error.codigo)
  }
);

// src/utiles/con-limite-de-tiempo.js
// Envuelve una promesa con un tiempo maximo de espera.

function conLimiteDeTiempo(promesa, limiteMs, mensaje = 'Tiempo de espera agotado') {
  let temporizador;

  const limite = new Promise((_, reject) => {
    temporizador = setTimeout(() => {
      const error = new Error(`${mensaje} (${limiteMs} ms)`);
      error.codigo = 'TIEMPO_AGOTADO';
      reject(error);
    }, limiteMs);
  });

  // El primero que se asiente gana.
  return Promise.race([promesa, limite]).finally(() => {
    // Limpiamos el temporizador para no retener el proceso vivo.
    clearTimeout(temporizador);
  });
}

module.exports = { conLimiteDeTiempo };

try {
  const pedidoPagado = await conLimiteDeTiempo(
    cobrarPedido(pedido),
    3000,
    'La pasarela de pago no responde'
  );
  console.log(`Cobrado: ${pedidoPagado.id}`);
} catch (error) {
  if (error.codigo === 'TIEMPO_AGOTADO') {
    console.error('Reintentar mas tarde o avisar al usuario.');
  }
  throw error;
}

// NO espera a nada: forEach ignora las promesas que devuelve el callback.
ids.forEach(async (id) => { await procesar(id); });
console.log('Terminado');   // Mentira: no ha terminado nada

// Correcto:
await Promise.all(ids.map((id) => procesar(id)));

// src/laboratorio/catalogo-promesas.js
// Compara la carga secuencial, paralela y resiliente del catalogo.

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

// buscarEvento viene de la leccion anterior (callback error-first).
const buscarEventoP = promisify(buscarEvento);

// 2. En serie: cada peticion espera a la anterior.
async function cargarCatalogoSerie(ids) {
  const eventos = [];
  for (const id of ids) {
    eventos.push(await buscarEventoP(id));
  }
  return eventos;
}

// 3. En paralelo: todas las peticiones arrancan a la vez.
async function cargarCatalogoParalelo(ids) {
  return Promise.all(ids.map((id) => buscarEventoP(id)));
}

// 5. Resiliente: los fallos parciales no invalidan el resto.
async function cargarCatalogoResiliente(ids) {
  const resultados = await Promise.allSettled(ids.map((id) => buscarEventoP(id)));

  const eventos = [];
  const fallos = [];

  resultados.forEach((resultado, indice) => {
    if (resultado.status === 'fulfilled') {
      eventos.push(resultado.value);
    } else {
      fallos.push({ id: ids[indice], motivo: resultado.reason.message });
    }
  });

  for (const fallo of fallos) {
    console.error(`[catalogo] no se pudo cargar ${fallo.id}: ${fallo.motivo}`);
  }

  return { eventos, fallos };
}

// --- Medicion ---
async function medir(etiqueta, funcion, ids) {
  const inicio = Date.now();
  const resultado = await funcion(ids);
  const ms = Date.now() - inicio;
  const cuantos = Array.isArray(resultado) ? resultado.length : resultado.eventos.length;
  return { etiqueta, eventos: cuantos, ms };
}

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

  const serie = await medir('serie', cargarCatalogoSerie, ids);
  const paralelo = await medir('paralelo', cargarCatalogoParalelo, ids);

  console.table([
    serie,
    paralelo,
    { etiqueta: 'mejora', eventos: '-', ms: `x${(serie.ms / paralelo.ms).toFixed(1)}` }
  ]);

  console.error('');
  console.error('--- Variante resiliente con un id inexistente ---');
  const resiliente = await cargarCatalogoResiliente([...ids, 'evt-999']);
  console.log(
    `Resiliente: ${resiliente.eventos.length} cargados, ${resiliente.fallos.length} fallidos`
  );
}

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

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

--- Variante resiliente con un id inexistente ---
[catalogo] no se pudo cargar evt-999: Evento no encontrado: evt-999
Resiliente: 3 cargados, 1 fallidos

// src/laboratorio/compra-robusta.js
// Flujo de compra con tiempo limite, reintentos selectivos y compensacion.

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

const CODIGOS_REINTENTABLES = new Set([
  'TIEMPO_AGOTADO', 'ETIMEDOUT', 'PASARELA_NO_DISPONIBLE'
]);

// --- Utilidades ---

function conLimiteDeTiempo(promesa, limiteMs, mensaje = 'Tiempo de espera agotado') {
  let temporizador;
  const limite = new Promise((_, reject) => {
    temporizador = setTimeout(() => {
      const error = new Error(`${mensaje} (${limiteMs} ms)`);
      error.codigo = 'TIEMPO_AGOTADO';
      reject(error);
    }, limiteMs);
  });
  return Promise.race([promesa, limite]).finally(() => clearTimeout(temporizador));
}

async function reintentar(operacion, { intentos = 3, esperaInicialMs = 200, factor = 2 } = {}) {
  for (let intento = 1; intento <= intentos; intento++) {
    try {
      return await operacion(intento);
    } catch (error) {
      const reintentable = CODIGOS_REINTENTABLES.has(error.codigo);

      if (!reintentable) {
        console.error(`[reintento] "${error.codigo}" no es reintentable. Abandono.`);
        throw error;
      }
      if (intento === intentos) {
        console.error(`[reintento] agotados los ${intentos} intentos.`);
        throw error;
      }

      const espera = esperaInicialMs * factor ** (intento - 1);
      console.error(
        `[reintento] intento ${intento}/${intentos} fallido (${error.message}). ` +
        `Reintento en ${espera} ms.`
      );
      await dormir(espera);
    }
  }
}

// --- Pasarela simulada ---

let llamadasAPasarela = 0;

function cobrarPedido(pedido) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      // Error de negocio: NO reintentable.
      if (pedido.totalCentimos > 20000) {
        const error = new Error(
          `Pago rechazado: ${(pedido.totalCentimos / 100).toFixed(2)} EUR supera el limite`
        );
        error.codigo = 'PAGO_RECHAZADO';
        reject(error);
        return;
      }

      // Error transitorio: las dos primeras llamadas fallan.
      llamadasAPasarela++;
      if (llamadasAPasarela <= 2) {
        const error = new Error('La pasarela no esta disponible');
        error.codigo = 'PASARELA_NO_DISPONIBLE';
        reject(error);
        return;
      }

      resolve({ ...pedido, estado: 'pagado' });
    }, 40);
  });
}

// --- Flujo de compra ---

async function comprarEntradas(usuarioId, eventoId, sesionId, cantidad) {
  const evento = await buscarEventoP(eventoId);
  await reservarEntradasP(sesionId, cantidad);

  try {
    const { sesion } = await buscarSesionP(sesionId);
    const pedido = await crearPedidoP(usuarioId, sesion, cantidad);

    // Reintentos por fuera, tiempo limite por dentro: cada intento
    // tiene sus propios 2 segundos.
    const pedidoPagado = await reintentar(
      () => conLimiteDeTiempo(cobrarPedido(pedido), 2000, 'La pasarela no responde'),
      { intentos: 3, esperaInicialMs: 200 }
    );

    const entradas = await emitirEntradasP(pedidoPagado);
    return { evento, sesion, pedido: pedidoPagado, entradas };
  } catch (error) {
    const libres = await liberarAforoP(sesionId, cantidad);
    console.error(`[compensacion] aforo liberado en ${sesionId}, quedan ${libres} libres`);
    throw error;
  }
}

// --- Pruebas ---

async function principal() {
  // Camino 1: 3 x 18,00 = 54,00 EUR. Falla dos veces y funciona a la tercera.
  console.error('--- Compra que acaba funcionando tras dos reintentos ---');
  const compra = await comprarEntradas('asis-001', 'evt-002', 'ses-002-2', 3);
  console.log(`Pedido ${compra.pedido.id} - ${compra.pedido.estado}`);
  console.log(`  Importe: ${(compra.pedido.totalCentimos / 100).toFixed(2)} EUR`);
  console.log(`  Entradas: ${compra.entradas.map((e) => e.codigo).join(', ')}`);

  // Camino 2: 5 x 42,00 = 210,00 EUR. Rechazo no reintentable.
  console.error('');
  console.error('--- Compra rechazada sin reintentos ---');
  try {
    await comprarEntradas('asis-002', 'evt-003', 'ses-003-2', 5);
  } catch (error) {
    console.error(`Resultado: [${error.codigo}] ${error.message}`);
  }
}

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

--- Compra que acaba funcionando tras dos reintentos ---
[reintento] intento 1/3 fallido (La pasarela no esta disponible). Reintento en 200 ms.
[reintento] intento 2/3 fallido (La pasarela no esta disponible). Reintento en 400 ms.
Pedido ped-001 - pagado
  Importe: 54.00 EUR
  Entradas: EV-2026-000001, EV-2026-000002, EV-2026-000003

--- Compra rechazada sin reintentos ---
[reintento] "PAGO_RECHAZADO" no es reintentable. Abandono.
[compensacion] aforo liberado en ses-003-2, quedan 180 libres
Resultado: [PAGO_RECHAZADO] Pago rechazado: 210.00 EUR supera el limite

// src/laboratorio/panel-ocupacion.js
// Panel de ocupacion de Escena Viva con paralelismo acotado y medicion del bucle.

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

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

// 1. Consulta simulada de una sesion.
function consultarOcupacion(sesionId, indice) {
  return new Promise((resolve) => {
    setTimeout(() => {
      const aforo = 420;
      const vendidas = (indice * 37) % aforo;
      resolve({
        sesionId,
        sala: SALAS[indice % SALAS.length],
        porcentaje: Math.round((vendidas / aforo) * 100),
        recaudacionCentimos: vendidas * 2500
      });
    }, LATENCIA_MS);
  });
}

// 2. Paralelismo acotado.
async function enLotes(elementos, tamanoLote, tarea) {
  const resultados = [];
  for (let i = 0; i < elementos.length; i += tamanoLote) {
    const lote = elementos.slice(i, i + tamanoLote);
    resultados.push(...await Promise.all(lote.map(tarea)));
  }
  return resultados;
}

async function generarPanel(idsSesiones, tamanoLote) {
  return enLotes(idsSesiones, tamanoLote, (id, i) => consultarOcupacion(id, i));
}

// 3. Agregacion por sala.
function agregarPorSala(ocupaciones) {
  const porSala = new Map();

  for (const o of ocupaciones) {
    const a = porSala.get(o.sala) ?? { sala: o.sala, sesiones: 0, sumaPorcentajes: 0, recaudacionCentimos: 0 };
    a.sesiones++;
    a.sumaPorcentajes += o.porcentaje;
    a.recaudacionCentimos += o.recaudacionCentimos;
    porSala.set(o.sala, a);
  }

  return [...porSala.values()].map((a) => ({
    sala: a.sala,
    sesiones: a.sesiones,
    ocupacionMedia: `${Math.round(a.sumaPorcentajes / a.sesiones)}%`,
    recaudacionEuros: (a.recaudacionCentimos / 100).toFixed(2)
  }));
}

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

  // 4. Medicion del retraso del bucle durante todo el proceso.
  const histograma = monitorEventLoopDelay({ resolution: 5 });
  histograma.enable();

  // 5. Comparativa de tamanos de lote.
  const comparativa = [];
  for (const tamanoLote of [1, 10, 50, 300]) {
    const inicio = Date.now();
    await generarPanel(ids, tamanoLote);
    comparativa.push({ tamanoLote, ms: Date.now() - inicio });
  }

  histograma.disable();

  const ocupaciones = await generarPanel(ids, 50);

  console.log('PANEL DE OCUPACION');
  console.table(agregarPorSala(ocupaciones));

  console.log('');
  console.log('TIEMPO SEGUN EL TAMANO DE LOTE');
  console.table(comparativa);

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

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

PANEL DE OCUPACION
┌─────────┬───────────────────┬──────────┬────────────────┬──────────────────┐
│ (index) │ sala              │ sesiones │ ocupacionMedia │ recaudacionEuros │
├─────────┼───────────────────┼──────────┼────────────────┼──────────────────┤
│ 0       │ 'Teatro Almendra' │ 100      │ '49%'          │ '515450.00'      │
│ 1       │ 'Sala Boveda'     │ 100      │ '50%'          │ '523900.00'      │
│ 2       │ 'Auditorio Ribera'│ 100      │ '50%'          │ '521100.00'      │
└─────────┴───────────────────┴──────────┴────────────────┴──────────────────┘

TIEMPO SEGUN EL TAMANO DE LOTE
┌─────────┬────────────┬──────┐
│ (index) │ tamanoLote │ ms   │
├─────────┼────────────┼──────┤
│ 0       │ 1          │ 9412 │
│ 1       │ 10         │ 942  │
│ 2       │ 50         │ 192  │
│ 3       │ 300        │ 32   │
└─────────┴────────────┴──────┘

Retraso del bucle: media 5.31 ms, p99 11.08 ms