// src/utiles/formato.mjs

// Opcion A: exportar en la propia declaracion.
export function formatearPrecio(centimos) {
  const euros = Math.floor(centimos / 100);
  const resto = String(centimos % 100).padStart(2, '0');
  return `${euros},${resto} EUR`;
}

export function formatearFecha(fechaISO) {
  const fecha = new Date(fechaISO);
  const dia = String(fecha.getDate()).padStart(2, '0');
  const mes = String(fecha.getMonth() + 1).padStart(2, '0');
  return `${dia}/${mes}/${fecha.getFullYear()}`;
}

export const SIMBOLO_MONEDA = 'EUR';

// Opcion B: exportar en bloque al final. Equivale al module.exports unico
// de CommonJS y tiene la misma ventaja: un indice de la API publica.
function formatearPrecio(centimos) { /* ... */ }
function formatearFecha(fechaISO) { /* ... */ }
const SIMBOLO_MONEDA = 'EUR';

export { formatearPrecio, formatearFecha, SIMBOLO_MONEDA };

// Importar lo que necesitas, por su nombre.
import { formatearPrecio, formatearFecha } from './utiles/formato.mjs';

// Renombrar, para evitar colisiones.
import { formatearPrecio as precio } from './utiles/formato.mjs';

// Importar TODO en un espacio de nombres.
import * as formato from './utiles/formato.mjs';
console.log(formato.formatearPrecio(2500));

// Importar solo por su efecto secundario (raro, pero existe).
import './configuracion-global.mjs';

// src/dominio/sesion.mjs
export default class Sesion {
  /* ... */
}

// Al importar, tu eliges el nombre: no hay llaves.
import Sesion from './dominio/sesion.mjs';
import LoQueSea from './dominio/sesion.mjs';   // Legal, y confuso

// src/dominio/evento.mjs
export default class Evento { /* ... */ }
export const ESTADOS_EVENTO = ['borrador', 'publicado', 'finalizado'];

import Evento, { ESTADOS_EVENTO } from './dominio/evento.mjs';

// src/dominio/index.mjs

// Reexportar TODO lo nombrado de cada modulo.
export * from './sesion.mjs';
export * from './evento.mjs';
export * from './gestor-ventas.mjs';

// O ser selectivo, que suele ser mejor.
export { Sesion } from './sesion.mjs';
export { Evento } from './evento.mjs';
export { GestorDeVentas, UMBRAL_AFORO_BAJO } from './gestor-ventas.mjs';

// Reexportar cambiando el nombre.
export { Sesion as SesionDeEvento } from './sesion.mjs';

export { default as Sesion } from './sesion.mjs';

// Todo esto es legal en CommonJS.
const modulo = require('./' + nombreDelModulo + '.js');

if (process.env.MODO === 'produccion') {
  registrador = require('./registrador-produccion.js');
}

for (const nombre of ['a', 'b', 'c']) {
  modulos[nombre] = require(`./plugins/${nombre}.js`);
}

function cargarPerezosamente() {
  const pesado = require('./modulo-muy-pesado.js');   // Solo si se llama
  return pesado.procesar();
}

// TODO esto es un SyntaxError en ESM.
import modulo from './' + nombre + '.mjs';        // Ruta no literal

if (produccion) {
  import registrador from './registrador.mjs';    // No en un bloque
}

function cargar() {
  import pesado from './pesado.mjs';              // No dentro de una funcion
}

// src/laboratorio/contador.mjs
export let cuenta = 0;
export function incrementar() {
  cuenta++;
}

// src/laboratorio/usar-contador.mjs
import { cuenta, incrementar } from './contador.mjs';

console.log(cuenta);   // 0
incrementar();
console.log(cuenta);   // 1  <-- El valor importado CAMBIO

// Esto funciona en ESM, aunque parezca imposible.
console.log(formatearPrecio(2500));            // 25,00 EUR
import { formatearPrecio } from './formato.mjs';

{
  "type": "module"
}

escena-viva/
├── package.json              { "type": "module" }
├── src/
│   ├── catalogo.js           -> ESM (por el package.json de la raiz)
│   ├── dominio/
│   │   └── evento.js         -> ESM
│   └── heredado/
│       ├── package.json      { "type": "commonjs" }
│       └── antiguo.js        -> CommonJS (por SU package.json)
└── herramientas/
    └── migrar.cjs            -> CommonJS (por la extension)

# Un fichero .mjs siempre es ESM
echo 'console.log(typeof require);' > prueba.mjs
node prueba.mjs
# ReferenceError: require is not defined in ES module scope

# El mismo contenido como .cjs
echo 'console.log(typeof require);' > prueba.cjs
node prueba.cjs
# function

// CommonJS: las cuatro formas funcionan.
require('./sesion');
require('./sesion.js');
require('./dominio');          // Encuentra dominio/index.js
require('./dominio/index.js');

// ESM: solo las rutas COMPLETAS funcionan.
import { Sesion } from './sesion.js';           // BIEN
import { Sesion } from './sesion';              // ERROR
import { Evento } from './dominio';             // ERROR: no busca index.js
import { Evento } from './dominio/index.js';    // BIEN

Error [ERR_MODULE_NOT_FOUND]: Cannot find module '/home/joan/escena-viva/src/sesion'
imported from /home/joan/escena-viva/src/catalogo.js
Did you mean to import ./sesion.js?

// src/laboratorio/metadatos.mjs
console.log(import.meta.url);
// file:///home/joan/escena-viva/src/laboratorio/metadatos.mjs

// src/utiles/rutas.mjs
import { fileURLToPath } from 'node:url';
import { dirname, join } from 'node:path';

// Equivalentes exactos de las variables de CommonJS.
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

console.log(__filename);   // /home/joan/escena-viva/src/utiles/rutas.mjs
console.log(__dirname);    // /home/joan/escena-viva/src/utiles

// Uso habitual: una ruta fiable a los datos.
const RUTA_DATOS = join(__dirname, '..', '..', 'datos', 'eventos.json');

const __dirname = import.meta.dirname;    // Directamente, sin conversion
const __filename = import.meta.filename;

// src/laboratorio/usar-require.mjs
import { createRequire } from 'node:module';

const require = createRequire(import.meta.url);

// Ahora funciona como en CommonJS, incluido el JSON.
const catalogo = require('../datos/eventos.json');
const paqueteAntiguo = require('paquete-solo-commonjs');

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

// src/informes/ocupacion.mjs
import { pathToFileURL } from 'node:url';

const esProgramaPrincipal = import.meta.url === pathToFileURL(process.argv[1]).href;

if (esProgramaPrincipal) {
  // Solo con: node src/informes/ocupacion.mjs
  ejecutarInforme();
}

// Sintaxis de atributos de importacion (Node 20.10+ / 22+).
import catalogo from '../datos/eventos.json' with { type: 'json' };

console.log(catalogo.length);

// src/laboratorio/carga.mjs
import { readFile } from 'node:fs/promises';

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

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

// CommonJS: hace falta una funcion envoltorio y su .catch.
const { readFile } = require('node:fs/promises');

async function principal() {
  const contenido = await readFile('datos/eventos.json', 'utf8');
  const catalogo = JSON.parse(contenido);
  console.log(`Cargados ${catalogo.length} eventos`);
}

principal().catch((error) => {
  console.error(error.message);
  process.exitCode = 1;
});

// 1. Inicializacion asincrona antes de exportar.
const configuracion = JSON.parse(await readFile('./config.json', 'utf8'));
export { configuracion };

// 2. Eleccion de dependencia en tiempo de ejecucion.
const registrador = process.env.NODE_ENV === 'produccion'
  ? await import('./registrador-produccion.mjs')
  : await import('./registrador-desarrollo.mjs');

// 3. Recursos que deben estar listos antes de que nadie use el modulo.
const conexion = await conectarABaseDeDatos();
export { conexion };

// Funciona tanto en ESM como en CommonJS.
const modulo = await import('./dominio/evento.mjs');
console.log(modulo.Evento);

// Con desestructuracion.
const { Evento } = await import('./dominio/evento.mjs');

// src/laboratorio/carga-condicional.mjs

const modo = process.env.NODE_ENV ?? 'desarrollo';

// La ruta puede ser una expresion: aqui si.
const { registrador } = await import(`./registradores/${modo}.mjs`);

registrador.info('Escena Viva arrancando');

// El generador de PDF de las entradas pesa mucho y rara vez se usa.
// No queremos cargarlo en el arranque de cada proceso.

export async function generarPdfEntrada(entrada) {
  const { crearPdf } = await import('./pdf/generador.mjs');
  return crearPdf(entrada);
}

// src/utiles/formato.cjs  (CommonJS)
function formatearPrecio(centimos) { /* ... */ }
function formatearFecha(fechaISO) { /* ... */ }

module.exports = { formatearPrecio, formatearFecha };

// src/catalogo.mjs  (ESM)

// El module.exports completo llega como exportacion POR DEFECTO.
import formato from './utiles/formato.cjs';
console.log(formato.formatearPrecio(2500));   // Siempre funciona

// Las exportaciones nombradas funcionan... si Node consigue detectarlas.
import { formatearPrecio } from './utiles/formato.cjs';   // Suele funcionar

// CommonJS con exports dinamicos: el analizador NO puede detectarlos.
const funciones = { formatearPrecio, formatearFecha };
for (const [nombre, fn] of Object.entries(funciones)) {
  module.exports[nombre] = fn;
}

// Desde ESM:
import { formatearPrecio } from './formato.cjs';
// SyntaxError: The requested module './formato.cjs' does not provide
// an export named 'formatearPrecio'

// Importa el objeto completo por defecto y desestructura despues.
import formato from './utiles/formato.cjs';
const { formatearPrecio, formatearFecha } = formato;

// src/antiguo.cjs
const { Evento } = require('./dominio/evento.mjs');

Error [ERR_REQUIRE_ESM]: require() of ES Module
/home/joan/escena-viva/src/dominio/evento.mjs not supported.
Instead change the require of evento.mjs to a dynamic import() which is
available in all CommonJS modules.

// src/antiguo.cjs
async function principal() {
  const { Evento } = await import('./dominio/evento.mjs');

  const evento = new Evento({ id: 'evt-001', titulo: 'Concierto de Otono' });
  console.log(evento.toString());
}

principal().catch((error) => {
  console.error(error.message);
  process.exitCode = 1;
});

// ---------- CommonJS ----------
function formatearPrecio(centimos) {
  const euros = Math.floor(centimos / 100);
  const resto = String(centimos % 100).padStart(2, '0');
  return `${euros},${resto} EUR`;
}

function formatearFecha(fechaISO) { /* ... */ }
function generarCodigoEntrada(anio, secuencia) { /* ... */ }

module.exports = { formatearPrecio, formatearFecha, generarCodigoEntrada };

// ---------- Módulos ES ----------
export function formatearPrecio(centimos) {
  const euros = Math.floor(centimos / 100);
  const resto = String(centimos % 100).padStart(2, '0');
  return `${euros},${resto} EUR`;
}

export function formatearFecha(fechaISO) { /* ... */ }
export function generarCodigoEntrada(anio, secuencia) { /* ... */ }

// ---------- CommonJS ----------
const { formatearPrecio, formatearFecha } = require('../utiles/formato.js');

class Sesion {
  #vendidas = 0;
  /* ... el cuerpo entero, sin un solo cambio ... */
}

module.exports = { Sesion };

// ---------- Módulos ES ----------
import { formatearPrecio, formatearFecha } from '../utiles/formato.js';

export class Sesion {
  #vendidas = 0;
  /* ... el cuerpo entero, sin un solo cambio ... */
}

// ---------- CommonJS ----------
const EventEmitter = require('node:events');

const UMBRAL_AFORO_BAJO = 0.10;

class GestorDeVentas extends EventEmitter { /* ... */ }

module.exports = { GestorDeVentas, UMBRAL_AFORO_BAJO };

// ---------- Módulos ES ----------
import { EventEmitter } from 'node:events';

export const UMBRAL_AFORO_BAJO = 0.10;

export class GestorDeVentas extends EventEmitter { /* ... */ }

// ---------- CommonJS ----------
const { Sesion } = require('./sesion.js');
const { Evento } = require('./evento.js');
const { GestorDeVentas, UMBRAL_AFORO_BAJO } = require('./gestor-ventas.js');

module.exports = { Sesion, Evento, GestorDeVentas, UMBRAL_AFORO_BAJO };

// ---------- Módulos ES ----------
export { Sesion } from './sesion.js';
export { Evento } from './evento.js';
export { GestorDeVentas, UMBRAL_AFORO_BAJO } from './gestor-ventas.js';

// ---------- CommonJS ----------
const catalogo = [ /* los 3 eventos */ ];

function obtenerCatalogo() {
  return structuredClone(catalogo);
}

function obtenerEventoPorId(id) { /* ... */ }

module.exports = { obtenerCatalogo, obtenerEventoPorId };

// ---------- Módulos ES ----------
// El array queda PRIVADO: al no exportarlo, nadie fuera puede tocarlo.
const catalogo = [ /* los 3 eventos */ ];

export function obtenerCatalogo() {
  return structuredClone(catalogo);
}

export function obtenerEventoPorId(id) { /* ... */ }

// ---------- CommonJS ----------
const { obtenerCatalogo } = require('./catalogo-datos.js');
const { Evento } = require('./dominio');                  // Sin extension: valido
const { formatearPrecio } = require('./utiles/formato.js');

function principal() { /* ... */ }

if (require.main === module) {
  principal();
}

module.exports = { leerOpciones, principal };

// ---------- Módulos ES ----------
import { pathToFileURL } from 'node:url';
import { obtenerCatalogo } from './catalogo-datos.js';
import { Evento } from './dominio/index.js';              // Extension OBLIGATORIA
import { formatearPrecio } from './utiles/formato.js';

export function principal() { /* ... */ }

// Equivalente de require.main === module
if (import.meta.url === pathToFileURL(process.argv[1]).href) {
  principal();
}

// src/catalogo-datos.mjs  (adelanto del modulo 3)
import { readFile } from 'node:fs/promises';
import { fileURLToPath } from 'node:url';
import { dirname, join } from 'node:path';

const __dirname = dirname(fileURLToPath(import.meta.url));
const RUTA_DATOS = join(__dirname, '..', 'datos', 'eventos.json');

// await de nivel superior: el catalogo se carga UNA VEZ, al importar el modulo.
// Quien importe este modulo recibira los datos ya listos.
const catalogo = JSON.parse(await readFile(RUTA_DATOS, 'utf8'));

export function obtenerCatalogo() {
  return structuredClone(catalogo);
}

export function obtenerEventoPorId(id) {
  const evento = catalogo.find((e) => e.id === id);
  return evento ? structuredClone(evento) : undefined;
}

// escena-viva-esm/package.json
{
  "type": "module"
}

// src/utiles/formato.js
export function formatearPrecio(centimos) {
  const euros = Math.floor(centimos / 100);
  const resto = String(centimos % 100).padStart(2, '0');
  return `${euros},${resto} EUR`;
}

export function formatearFecha(fechaISO) {
  const fecha = new Date(fechaISO);
  const dia = String(fecha.getDate()).padStart(2, '0');
  const mes = String(fecha.getMonth() + 1).padStart(2, '0');
  const anio = fecha.getFullYear();
  const hora = String(fecha.getHours()).padStart(2, '0');
  const minuto = String(fecha.getMinutes()).padStart(2, '0');
  return `${dia}/${mes}/${anio} ${hora}:${minuto}`;
}

export function generarCodigoEntrada(anio, secuencia) {
  return `EV-${anio}-${String(secuencia).padStart(6, '0')}`;
}

// src/dominio/sesion.js
import { formatearPrecio, formatearFecha } from '../utiles/formato.js';

export class Sesion {
  #vendidas = 0;

  constructor({ id, fechaHora, aforo, vendidas = 0, precioCentimos }) {
    this.id = id;
    this.fechaHora = fechaHora;
    this.aforo = aforo;
    this.precioCentimos = precioCentimos;
    this.#vendidas = vendidas;
  }

  get vendidas() { return this.#vendidas; }
  get libres() { return this.aforo - this.#vendidas; }
  get ocupacion() { return Math.round((this.#vendidas / this.aforo) * 100); }
  get agotada() { return this.libres === 0; }
  get precioEuros() { return (this.precioCentimos / 100).toFixed(2); }
  get recaudacionCentimos() { return this.#vendidas * this.precioCentimos; }

  vender(cantidad = 1) {
    if (!Number.isInteger(cantidad) || cantidad < 1) {
      const error = new Error('La cantidad debe ser un entero positivo');
      error.codigo = 'CANTIDAD_INVALIDA';
      throw error;
    }
    if (cantidad > this.libres) {
      const error = new Error(`Aforo insuficiente en ${this.id}: quedan ${this.libres}`);
      error.codigo = 'AFORO_INSUFICIENTE';
      throw error;
    }
    this.#vendidas += cantidad;
    return this.#vendidas;
  }

  describir() {
    return (
      `${formatearFecha(this.fechaHora)}  ${formatearPrecio(this.precioCentimos)}  ` +
      `${this.libres}/${this.aforo} libres  (${this.ocupacion}% ocupado)` +
      (this.agotada ? '  [AGOTADA]' : '')
    );
  }

  toJSON() {
    return {
      id: this.id,
      fechaHora: this.fechaHora,
      aforo: this.aforo,
      vendidas: this.#vendidas,
      precioCentimos: this.precioCentimos
    };
  }
}

// src/dominio/index.js
export { Sesion } from './sesion.js';
export { Evento } from './evento.js';
export { GestorDeVentas, UMBRAL_AFORO_BAJO } from './gestor-ventas.js';

// src/catalogo.js  (solo las partes que cambian)
import { pathToFileURL } from 'node:url';
import { obtenerCatalogo } from './catalogo-datos.js';
import { Evento } from './dominio/index.js';
import { formatearPrecio } from './utiles/formato.js';

export function leerOpciones(argumentos) { /* identico */ }

export function principal() { /* identico */ }

if (import.meta.url === pathToFileURL(process.argv[1]).href) {
  principal();
}

node src/catalogo.js --tabla
# Salida IDENTICA a la version CommonJS
# 3 eventos | aforo 3000 | vendidas 1811 | libres 1189 | recaudacion 62298,00 EUR

// src/utiles/formato.cjs
// CommonJS con exports ESTATICOS: el analizador de Node los detecta.
function formatearPrecio(centimos) {
  const euros = Math.floor(centimos / 100);
  return `${euros},${String(centimos % 100).padStart(2, '0')} EUR`;
}

function formatearFecha(fechaISO) {
  return fechaISO.slice(0, 10).split('-').reverse().join('/');
}

module.exports = { formatearPrecio, formatearFecha };

// src/utiles/legado-dinamico.cjs
// CommonJS con exports DINAMICOS: el analizador NO puede detectarlos.
function calcularOcupacion(sesion) {
  return Math.round((sesion.vendidas / sesion.aforo) * 100);
}

function calcularLibres(sesion) {
  return sesion.aforo - sesion.vendidas;
}

// Construccion dinamica: solo se sabe en tiempo de ejecucion.
const funciones = { calcularOcupacion, calcularLibres };
for (const [nombre, fn] of Object.entries(funciones)) {
  module.exports[nombre] = fn;
}

// src/dominio/sesion.mjs
// ESM importando CommonJS en sus dos variantes.

// 1. Exports estaticos: la importacion nombrada FUNCIONA.
import { formatearPrecio } from '../utiles/formato.cjs';

// 2. Exports dinamicos: la nombrada FALLARIA.
//    import { calcularOcupacion } from '../utiles/legado-dinamico.cjs';
//    SyntaxError: does not provide an export named 'calcularOcupacion'
//
//    Solucion universal: importar por defecto y desestructurar.
import legado from '../utiles/legado-dinamico.cjs';
const { calcularOcupacion, calcularLibres } = legado;

export class Sesion {
  constructor({ id, aforo, vendidas = 0, precioCentimos }) {
    this.id = id;
    this.aforo = aforo;
    this.vendidas = vendidas;
    this.precioCentimos = precioCentimos;
  }

  describir() {
    return (
      `${this.id}  ${formatearPrecio(this.precioCentimos)}  ` +
      `${calcularLibres(this)} libres  (${calcularOcupacion(this)}%)`
    );
  }
}

// src/informe.cjs
// CommonJS que necesita una clase definida en un modulo ES.

// 1. Demostracion de que require FALLA.
try {
  const { Sesion } = require('./dominio/sesion.mjs');
  console.log('Esto no se imprime:', Sesion);
} catch (error) {
  console.error(`require fallo con codigo: ${error.code}`);
  console.error(`  ${error.message.split('\n')[0]}`);
}

// 2. Solucion con importacion dinamica.
async function principal() {
  const { Sesion } = await import('./dominio/sesion.mjs');

  const sesion = new Sesion({
    id: 'ses-002-1', aforo: 120, vendidas: 118, precioCentimos: 1800
  });

  console.log('');
  console.log('Con await import() SI funciona:');
  console.log(`  ${sesion.describir()}`);
}

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

node src/informe.cjs

require fallo con codigo: ERR_REQUIRE_ESM
  require() of ES Module /home/joan/escena-viva-mixto/src/dominio/sesion.mjs not supported.

Con await import() SI funciona:
  ses-002-1  18,00 EUR  2 libres  (98%)

// src/catalogo-datos.mjs
// Carga del catalogo con await de nivel superior. Exclusivo de ESM.

import { readFile } from 'node:fs/promises';
import { fileURLToPath } from 'node:url';
import { dirname, join } from 'node:path';

const __dirname = dirname(fileURLToPath(import.meta.url));
const RUTA_DATOS = join(__dirname, '..', 'datos', 'eventos.json');

// 1 y 2. Carga con await de nivel superior y degradacion elegante ante el fallo.
let catalogo = [];

try {
  const contenido = await readFile(RUTA_DATOS, 'utf8');
  catalogo = JSON.parse(contenido);
  console.error(`[catalogo] cargados ${catalogo.length} eventos desde ${RUTA_DATOS}`);
} catch (error) {
  if (error.code === 'ENOENT') {
    console.error(`[catalogo] AVISO: no se encontro ${RUTA_DATOS}. Catalogo vacio.`);
  } else if (error instanceof SyntaxError) {
    console.error(`[catalogo] AVISO: el fichero no es JSON valido (${error.message}).`);
  } else {
    console.error(`[catalogo] AVISO: fallo de lectura (${error.message}).`);
  }
  // No relanzamos: la aplicacion arranca con el catalogo vacio.
}

// 4. Marca de tiempo del momento de la carga.
export const CARGADO_EN = new Date().toISOString();

// 3. Acceso a los datos, siempre con copias.
export function obtenerCatalogo() {
  return structuredClone(catalogo);
}

export function obtenerEventoPorId(id) {
  const evento = catalogo.find((e) => e.id === id);
  return evento ? structuredClone(evento) : undefined;
}

export function obtenerSesion(sesionId) {
  for (const evento of catalogo) {
    const sesion = evento.sesiones.find((s) => s.id === sesionId);
    if (sesion) {
      return structuredClone({ evento: { id: evento.id, titulo: evento.titulo }, sesion });
    }
  }
  return undefined;
}

// src/consumidor-a.mjs
import { CARGADO_EN, obtenerCatalogo } from './catalogo-datos.mjs';

export function informar() {
  return { modulo: 'consumidor-a', cargadoEn: CARGADO_EN, eventos: obtenerCatalogo().length };
}

// src/consumidor-b.mjs
import { CARGADO_EN, obtenerEventoPorId } from './catalogo-datos.mjs';

export function informar() {
  const evento = obtenerEventoPorId('evt-002');
  return { modulo: 'consumidor-b', cargadoEn: CARGADO_EN, titulo: evento?.titulo ?? '(sin datos)' };
}

// src/principal.mjs
// Sin funcion envolvente: await de nivel superior en todo el fichero.

import { setTimeout as dormir } from 'node:timers/promises';
import { CARGADO_EN, obtenerCatalogo, obtenerSesion } from './catalogo-datos.mjs';
import { informar as informarA } from './consumidor-a.mjs';
import { informar as informarB } from './consumidor-b.mjs';

const eventos = obtenerCatalogo();

console.log('CATALOGO');
console.table(eventos.map((e) => ({
  id: e.id,
  titulo: e.titulo,
  sala: e.sala,
  sesiones: e.sesiones.length,
  aforo: e.sesiones.reduce((t, s) => t + s.aforo, 0),
  vendidas: e.sesiones.reduce((t, s) => t + s.vendidas, 0)
})));

const encontrada = obtenerSesion('ses-002-1');
console.log('');
console.log(`Sesion ses-002-1: ${encontrada.evento.titulo}, ` +
  `${encontrada.sesion.aforo - encontrada.sesion.vendidas} libres`);

// Pausa con await de nivel superior: imposible en CommonJS.
await dormir(50);

// 4. La marca de tiempo es la MISMA en los tres modulos.
console.log('');
console.log('CACHE DE MODULOS EN ESM');
console.table([
  { modulo: 'principal', cargadoEn: CARGADO_EN, dato: `${eventos.length} eventos` },
  { ...informarA(), dato: `${informarA().eventos} eventos` },
  { ...informarB(), dato: informarB().titulo }
]);

const todasIguales = CARGADO_EN === informarA().cargadoEn && CARGADO_EN === informarB().cargadoEn;
console.log('');
console.log(`¿Misma marca de tiempo en los tres modulos? ${todasIguales}`);

[catalogo] cargados 3 eventos desde /home/joan/escena-viva-esm/datos/eventos.json
CATALOGO
┌─────────┬───────────┬────────────────────────────────┬────────────────────┬──────────┬───────┬──────────┐
│ (index) │ id        │ titulo                         │ sala               │ sesiones │ aforo │ vendidas │
├─────────┼───────────┼────────────────────────────────┼────────────────────┼──────────┼───────┼──────────┤
│ 0       │ 'evt-001' │ 'Concierto de Otono'           │ 'Teatro Almendra'  │ 2        │ 840   │ 276      │
│ 1       │ 'evt-002' │ 'Noche de Monologos'           │ 'Sala Boveda'      │ 3        │ 360   │ 175      │
│ 2       │ 'evt-003' │ 'Festival de Jazz de Primavera'│ 'Auditorio Ribera' │ 2        │ 1800  │ 1360     │
└─────────┴───────────┴────────────────────────────────┴────────────────────┴──────────┴───────┴──────────┘

Sesion ses-002-1: Noche de Monologos, 2 libres

CACHE DE MODULOS EN ESM
┌─────────┬───────────────┬────────────────────────────┬──────────────────────┐
│ (index) │ modulo        │ cargadoEn                  │ dato                 │
├─────────┼───────────────┼────────────────────────────┼──────────────────────┤
│ 0       │ 'principal'   │ '2026-08-11T18:42:07.331Z' │ '3 eventos'          │
│ 1       │ 'consumidor-a'│ '2026-08-11T18:42:07.331Z' │ '3 eventos'          │
│ 2       │ 'consumidor-b'│ '2026-08-11T18:42:07.331Z' │ 'Noche de Monologos' │
└─────────┴───────────────┴────────────────────────────┴──────────────────────┘

¿Misma marca de tiempo en los tres modulos? true