// src/utils/format.mjs

// Opcio A: exportar a la mateixa declaracio.
export function formatarPreu(centims) {
  const euros = Math.floor(centims / 100);
  const resta = String(centims % 100).padStart(2, '0');
  return `${euros},${resta} EUR`;
}

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

export const SIMBOL_MONEDA = 'EUR';

// Opcio B: exportar en bloc al final. Equival al module.exports unic
// de CommonJS i te el mateix avantatge: un index de l'API publica.
function formatarPreu(centims) { /* ... */ }
function formatarData(dataISO) { /* ... */ }
const SIMBOL_MONEDA = 'EUR';

export { formatarPreu, formatarData, SIMBOL_MONEDA };

// Importar el que necessites, pel seu nom.
import { formatarPreu, formatarData } from './utils/format.mjs';

// Reanomenar, per evitar collisions.
import { formatarPreu as preu } from './utils/format.mjs';

// Importar-ho TOT en un espai de noms.
import * as format from './utils/format.mjs';
console.log(format.formatarPreu(2500));

// Importar nomes pel seu efecte secundari (rar, pero existeix).
import './configuracio-global.mjs';

// src/domini/sessio.mjs
export default class Sessio {
  /* ... */
}

// En importar, tu tries el nom: no hi ha claus.
import Sessio from './domini/sessio.mjs';
import ElQueSigui from './domini/sessio.mjs';   // Legal, i confus

// src/domini/esdeveniment.mjs
export default class Esdeveniment { /* ... */ }
export const ESTATS_ESDEVENIMENT = ['esborrany', 'publicat', 'finalitzat'];

import Esdeveniment, { ESTATS_ESDEVENIMENT } from './domini/esdeveniment.mjs';

// src/domini/index.mjs

// Reexportar TOT el que te nom de cada modul.
export * from './sessio.mjs';
export * from './esdeveniment.mjs';
export * from './gestor-vendes.mjs';

// O ser selectiu, que sol ser millor.
export { Sessio } from './sessio.mjs';
export { Esdeveniment } from './esdeveniment.mjs';
export { GestorDeVendes, LLINDAR_AFORAMENT_BAIX } from './gestor-vendes.mjs';

// Reexportar canviant el nom.
export { Sessio as SessioDEsdeveniment } from './sessio.mjs';

export { default as Sessio } from './sessio.mjs';

// Tot aixo es legal en CommonJS.
const modul = require('./' + nomDelModul + '.js');

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

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

function carregarMandrosament() {
  const pesat = require('./modul-molt-pesat.js');   // Nomes si es crida
  return pesat.processar();
}

// TOT aixo es un SyntaxError en ESM.
import modul from './' + nom + '.mjs';            // Ruta no literal

if (produccio) {
  import registrador from './registrador.mjs';    // No dins d'un bloc
}

function carregar() {
  import pesat from './pesat.mjs';                // No dins d'una funcio
}

// src/laboratori/comptador.mjs
export let compte = 0;
export function incrementar() {
  compte++;
}

// src/laboratori/usar-comptador.mjs
import { compte, incrementar } from './comptador.mjs';

console.log(compte);   // 0
incrementar();
console.log(compte);   // 1  <-- El valor importat HA CANVIAT

// Aixo funciona en ESM, encara que sembli impossible.
console.log(formatarPreu(2500));            // 25,00 EUR
import { formatarPreu } from './format.mjs';

{
  "type": "module"
}

escena-viva/
├── package.json                { "type": "module" }
├── src/
│   ├── cataleg.js              -> ESM (pel package.json de l'arrel)
│   ├── domini/
│   │   └── esdeveniment.js     -> ESM
│   └── heretat/
│       ├── package.json        { "type": "commonjs" }
│       └── antic.js            -> CommonJS (pel SEU package.json)
└── eines/
    └── migrar.cjs              -> CommonJS (per l'extensio)

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

# El mateix contingut com a .cjs
echo 'console.log(typeof require);' > prova.cjs
node prova.cjs
# function

// CommonJS: les quatre formes funcionen.
require('./sessio');
require('./sessio.js');
require('./domini');          // Troba domini/index.js
require('./domini/index.js');

// ESM: nomes les rutes COMPLETES funcionen.
import { Sessio } from './sessio.js';                 // BE
import { Sessio } from './sessio';                    // ERROR
import { Esdeveniment } from './domini';              // ERROR: no busca index.js
import { Esdeveniment } from './domini/index.js';     // BE

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

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

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

// Equivalents exactes de les variables de CommonJS.
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

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

// Us habitual: una ruta fiable a les dades.
const RUTA_DADES = join(__dirname, '..', '..', 'dades', 'esdeveniments.json');

const __dirname = import.meta.dirname;    // Directament, sense conversio
const __filename = import.meta.filename;

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

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

// Ara funciona com en CommonJS, inclos el JSON.
const cataleg = require('../dades/esdeveniments.json');
const paquetAntic = require('paquet-nomes-commonjs');

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

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

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

if (esProgramaPrincipal) {
  // Nomes amb: node src/informes/ocupacio.mjs
  executarInforme();
}

// Sintaxi d'atributs d'importacio (Node 20.10+ / 22+).
import cataleg from '../dades/esdeveniments.json' with { type: 'json' };

console.log(cataleg.length);

// src/laboratori/carrega.mjs
import { readFile } from 'node:fs/promises';

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

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

// CommonJS: cal una funcio embolcall i el seu .catch.
const { readFile } = require('node:fs/promises');

async function principal() {
  const contingut = await readFile('dades/esdeveniments.json', 'utf8');
  const cataleg = JSON.parse(contingut);
  console.log(`Carregats ${cataleg.length} esdeveniments`);
}

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

// 1. Inicialitzacio asincrona abans d'exportar.
const configuracio = JSON.parse(await readFile('./config.json', 'utf8'));
export { configuracio };

// 2. Eleccio de dependencia en temps d'execucio.
const registrador = process.env.NODE_ENV === 'produccio'
  ? await import('./registrador-produccio.mjs')
  : await import('./registrador-desenvolupament.mjs');

// 3. Recursos que han d'estar a punt abans que ningu faci servir el modul.
const connexio = await connectarABaseDeDades();
export { connexio };

// Funciona tant en ESM com en CommonJS.
const modul = await import('./domini/esdeveniment.mjs');
console.log(modul.Esdeveniment);

// Amb desestructuracio.
const { Esdeveniment } = await import('./domini/esdeveniment.mjs');

// src/laboratori/carrega-condicional.mjs

const mode = process.env.NODE_ENV ?? 'desenvolupament';

// La ruta pot ser una expressio: aqui si.
const { registrador } = await import(`./registradors/${mode}.mjs`);

registrador.info('Escena Viva arrencant');

// El generador de PDF de les entrades pesa molt i poques vegades es fa servir.
// No el volem carregar a l'arrencada de cada proces.

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

// src/utils/format.cjs  (CommonJS)
function formatarPreu(centims) { /* ... */ }
function formatarData(dataISO) { /* ... */ }

module.exports = { formatarPreu, formatarData };

// src/cataleg.mjs  (ESM)

// El module.exports complet arriba com a exportacio PER DEFECTE.
import format from './utils/format.cjs';
console.log(format.formatarPreu(2500));   // Sempre funciona

// Les exportacions amb nom funcionen... si Node aconsegueix detectar-les.
import { formatarPreu } from './utils/format.cjs';   // Sol funcionar

// CommonJS amb exports dinamics: l'analitzador NO els pot detectar.
const funcions = { formatarPreu, formatarData };
for (const [nom, fn] of Object.entries(funcions)) {
  module.exports[nom] = fn;
}

// Des d'ESM:
import { formatarPreu } from './format.cjs';
// SyntaxError: The requested module './format.cjs' does not provide
// an export named 'formatarPreu'

// Importa l'objecte complet per defecte i desestructura despres.
import format from './utils/format.cjs';
const { formatarPreu, formatarData } = format;

// src/antic.cjs
const { Esdeveniment } = require('./domini/esdeveniment.mjs');

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

// src/antic.cjs
async function principal() {
  const { Esdeveniment } = await import('./domini/esdeveniment.mjs');

  const esdeveniment = new Esdeveniment({ id: 'evt-001', titol: 'Concierto de Otono' });
  console.log(esdeveniment.toString());
}

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

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

function formatarData(dataISO) { /* ... */ }
function generarCodiEntrada(any, sequencia) { /* ... */ }

module.exports = { formatarPreu, formatarData, generarCodiEntrada };

// ---------- Mòduls ES ----------
export function formatarPreu(centims) {
  const euros = Math.floor(centims / 100);
  const resta = String(centims % 100).padStart(2, '0');
  return `${euros},${resta} EUR`;
}

export function formatarData(dataISO) { /* ... */ }
export function generarCodiEntrada(any, sequencia) { /* ... */ }

// ---------- CommonJS ----------
const { formatarPreu, formatarData } = require('../utils/format.js');

class Sessio {
  #venudes = 0;
  /* ... el cos sencer, sense ni un sol canvi ... */
}

module.exports = { Sessio };

// ---------- Mòduls ES ----------
import { formatarPreu, formatarData } from '../utils/format.js';

export class Sessio {
  #venudes = 0;
  /* ... el cos sencer, sense ni un sol canvi ... */
}

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

const LLINDAR_AFORAMENT_BAIX = 0.10;

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

module.exports = { GestorDeVendes, LLINDAR_AFORAMENT_BAIX };

// ---------- Mòduls ES ----------
import { EventEmitter } from 'node:events';

export const LLINDAR_AFORAMENT_BAIX = 0.10;

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

// ---------- CommonJS ----------
const { Sessio } = require('./sessio.js');
const { Esdeveniment } = require('./esdeveniment.js');
const { GestorDeVendes, LLINDAR_AFORAMENT_BAIX } = require('./gestor-vendes.js');

module.exports = { Sessio, Esdeveniment, GestorDeVendes, LLINDAR_AFORAMENT_BAIX };

// ---------- Mòduls ES ----------
export { Sessio } from './sessio.js';
export { Esdeveniment } from './esdeveniment.js';
export { GestorDeVendes, LLINDAR_AFORAMENT_BAIX } from './gestor-vendes.js';

// ---------- CommonJS ----------
const cataleg = [ /* els 3 esdeveniments */ ];

function obtenirCataleg() {
  return structuredClone(cataleg);
}

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

module.exports = { obtenirCataleg, obtenirEsdevenimentPerId };

// ---------- Mòduls ES ----------
// L'array queda PRIVAT: en no exportar-lo, ningu de fora no el pot tocar.
const cataleg = [ /* els 3 esdeveniments */ ];

export function obtenirCataleg() {
  return structuredClone(cataleg);
}

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

// ---------- CommonJS ----------
const { obtenirCataleg } = require('./cataleg-dades.js');
const { Esdeveniment } = require('./domini');              // Sense extensio: valid
const { formatarPreu } = require('./utils/format.js');

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

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

module.exports = { llegirOpcions, principal };

// ---------- Mòduls ES ----------
import { pathToFileURL } from 'node:url';
import { obtenirCataleg } from './cataleg-dades.js';
import { Esdeveniment } from './domini/index.js';          // Extensio OBLIGATORIA
import { formatarPreu } from './utils/format.js';

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

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

// src/cataleg-dades.mjs  (avancament del modul 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_DADES = join(__dirname, '..', 'dades', 'esdeveniments.json');

// await de nivell superior: el cataleg es carrega UN COP, en importar el modul.
// Qui importi aquest modul rebra les dades ja a punt.
const cataleg = JSON.parse(await readFile(RUTA_DADES, 'utf8'));

export function obtenirCataleg() {
  return structuredClone(cataleg);
}

export function obtenirEsdevenimentPerId(id) {
  const esdeveniment = cataleg.find((e) => e.id === id);
  return esdeveniment ? structuredClone(esdeveniment) : undefined;
}

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

// src/utils/format.js
export function formatarPreu(centims) {
  const euros = Math.floor(centims / 100);
  const resta = String(centims % 100).padStart(2, '0');
  return `${euros},${resta} EUR`;
}

export function formatarData(dataISO) {
  const data = new Date(dataISO);
  const dia = String(data.getDate()).padStart(2, '0');
  const mes = String(data.getMonth() + 1).padStart(2, '0');
  const any = data.getFullYear();
  const hora = String(data.getHours()).padStart(2, '0');
  const minut = String(data.getMinutes()).padStart(2, '0');
  return `${dia}/${mes}/${any} ${hora}:${minut}`;
}

export function generarCodiEntrada(any, sequencia) {
  return `EV-${any}-${String(sequencia).padStart(6, '0')}`;
}

// src/domini/sessio.js
import { formatarPreu, formatarData } from '../utils/format.js';

export class Sessio {
  #venudes = 0;

  constructor({ id, dataHora, aforament, venudes = 0, preuCentims }) {
    this.id = id;
    this.dataHora = dataHora;
    this.aforament = aforament;
    this.preuCentims = preuCentims;
    this.#venudes = venudes;
  }

  get venudes() { return this.#venudes; }
  get lliures() { return this.aforament - this.#venudes; }
  get ocupacio() { return Math.round((this.#venudes / this.aforament) * 100); }
  get exhaurida() { return this.lliures === 0; }
  get preuEuros() { return (this.preuCentims / 100).toFixed(2); }
  get recaptacioCentims() { return this.#venudes * this.preuCentims; }

  vendre(quantitat = 1) {
    if (!Number.isInteger(quantitat) || quantitat < 1) {
      const error = new Error('La quantitat ha de ser un enter positiu');
      error.codi = 'QUANTITAT_INVALIDA';
      throw error;
    }
    if (quantitat > this.lliures) {
      const error = new Error(`Aforament insuficient a ${this.id}: en queden ${this.lliures}`);
      error.codi = 'AFORAMENT_INSUFICIENT';
      throw error;
    }
    this.#venudes += quantitat;
    return this.#venudes;
  }

  descriure() {
    return (
      `${formatarData(this.dataHora)}  ${formatarPreu(this.preuCentims)}  ` +
      `${this.lliures}/${this.aforament} lliures  (${this.ocupacio}% ocupat)` +
      (this.exhaurida ? '  [EXHAURIDA]' : '')
    );
  }

  toJSON() {
    return {
      id: this.id,
      dataHora: this.dataHora,
      aforament: this.aforament,
      venudes: this.#venudes,
      preuCentims: this.preuCentims
    };
  }
}

// src/domini/index.js
export { Sessio } from './sessio.js';
export { Esdeveniment } from './esdeveniment.js';
export { GestorDeVendes, LLINDAR_AFORAMENT_BAIX } from './gestor-vendes.js';

// src/cataleg.js  (nomes les parts que canvien)
import { pathToFileURL } from 'node:url';
import { obtenirCataleg } from './cataleg-dades.js';
import { Esdeveniment } from './domini/index.js';
import { formatarPreu } from './utils/format.js';

export function llegirOpcions(parametres) { /* identic */ }

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

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

node src/cataleg.js --taula
# Sortida IDENTICA a la versio CommonJS
# 3 esdeveniments | aforament 3000 | venudes 1811 | lliures 1189 | recaptacio 62298,00 EUR

// src/utils/format.cjs
// CommonJS amb exports ESTATICS: l'analitzador de Node els detecta.
function formatarPreu(centims) {
  const euros = Math.floor(centims / 100);
  return `${euros},${String(centims % 100).padStart(2, '0')} EUR`;
}

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

module.exports = { formatarPreu, formatarData };

// src/utils/llegat-dinamic.cjs
// CommonJS amb exports DINAMICS: l'analitzador NO els pot detectar.
function calcularOcupacio(sessio) {
  return Math.round((sessio.venudes / sessio.aforament) * 100);
}

function calcularLliures(sessio) {
  return sessio.aforament - sessio.venudes;
}

// Construccio dinamica: nomes se sap en temps d'execucio.
const funcions = { calcularOcupacio, calcularLliures };
for (const [nom, fn] of Object.entries(funcions)) {
  module.exports[nom] = fn;
}

// src/domini/sessio.mjs
// ESM important CommonJS en les seves dues variants.

// 1. Exports estatics: la importacio amb nom FUNCIONA.
import { formatarPreu } from '../utils/format.cjs';

// 2. Exports dinamics: la que te nom FALLARIA.
//    import { calcularOcupacio } from '../utils/llegat-dinamic.cjs';
//    SyntaxError: does not provide an export named 'calcularOcupacio'
//
//    Solucio universal: importar per defecte i desestructurar.
import llegat from '../utils/llegat-dinamic.cjs';
const { calcularOcupacio, calcularLliures } = llegat;

export class Sessio {
  constructor({ id, aforament, venudes = 0, preuCentims }) {
    this.id = id;
    this.aforament = aforament;
    this.venudes = venudes;
    this.preuCentims = preuCentims;
  }

  descriure() {
    return (
      `${this.id}  ${formatarPreu(this.preuCentims)}  ` +
      `${calcularLliures(this)} lliures  (${calcularOcupacio(this)}%)`
    );
  }
}

// src/informe.cjs
// CommonJS que necessita una classe definida en un modul ES.

// 1. Demostracio que require FALLA.
try {
  const { Sessio } = require('./domini/sessio.mjs');
  console.log("Aixo no s'imprimeix:", Sessio);
} catch (error) {
  console.error(`require ha fallat amb codi: ${error.code}`);
  console.error(`  ${error.message.split('\n')[0]}`);
}

// 2. Solucio amb importacio dinamica.
async function principal() {
  const { Sessio } = await import('./domini/sessio.mjs');

  const sessio = new Sessio({
    id: 'ses-002-1', aforament: 120, venudes: 118, preuCentims: 1800
  });

  console.log('');
  console.log('Amb await import() SI que funciona:');
  console.log(`  ${sessio.descriure()}`);
}

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

node src/informe.cjs

require ha fallat amb codi: ERR_REQUIRE_ESM
  require() of ES Module /home/joan/escena-viva-mixt/src/domini/sessio.mjs not supported.

Amb await import() SI que funciona:
  ses-002-1  18,00 EUR  2 lliures  (98%)

// src/cataleg-dades.mjs
// Carrega del cataleg amb await de nivell superior. Exclusiu d'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_DADES = join(__dirname, '..', 'dades', 'esdeveniments.json');

// 1 i 2. Carrega amb await de nivell superior i degradacio elegant davant la fallada.
let cataleg = [];

try {
  const contingut = await readFile(RUTA_DADES, 'utf8');
  cataleg = JSON.parse(contingut);
  console.error(`[cataleg] carregats ${cataleg.length} esdeveniments des de ${RUTA_DADES}`);
} catch (error) {
  if (error.code === 'ENOENT') {
    console.error(`[cataleg] AVIS: no s'ha trobat ${RUTA_DADES}. Cataleg buit.`);
  } else if (error instanceof SyntaxError) {
    console.error(`[cataleg] AVIS: el fitxer no es JSON valid (${error.message}).`);
  } else {
    console.error(`[cataleg] AVIS: fallada de lectura (${error.message}).`);
  }
  // No el rellancem: l'aplicacio arrenca amb el cataleg buit.
}

// 4. Marca de temps del moment de la carrega.
export const CARREGAT_EL = new Date().toISOString();

// 3. Acces a les dades, sempre amb copies.
export function obtenirCataleg() {
  return structuredClone(cataleg);
}

export function obtenirEsdevenimentPerId(id) {
  const esdeveniment = cataleg.find((e) => e.id === id);
  return esdeveniment ? structuredClone(esdeveniment) : undefined;
}

export function obtenirSessio(sessioId) {
  for (const esdeveniment of cataleg) {
    const sessio = esdeveniment.sessions.find((s) => s.id === sessioId);
    if (sessio) {
      return structuredClone({ esdeveniment: { id: esdeveniment.id, titol: esdeveniment.titol }, sessio });
    }
  }
  return undefined;
}

// src/consumidor-a.mjs
import { CARREGAT_EL, obtenirCataleg } from './cataleg-dades.mjs';

export function informar() {
  return { modul: 'consumidor-a', carregatEl: CARREGAT_EL, esdeveniments: obtenirCataleg().length };
}

// src/consumidor-b.mjs
import { CARREGAT_EL, obtenirEsdevenimentPerId } from './cataleg-dades.mjs';

export function informar() {
  const esdeveniment = obtenirEsdevenimentPerId('evt-002');
  return { modul: 'consumidor-b', carregatEl: CARREGAT_EL, titol: esdeveniment?.titol ?? '(sense dades)' };
}

// src/principal.mjs
// Sense funcio embolcalladora: await de nivell superior a tot el fitxer.

import { setTimeout as dormir } from 'node:timers/promises';
import { CARREGAT_EL, obtenirCataleg, obtenirSessio } from './cataleg-dades.mjs';
import { informar as informarA } from './consumidor-a.mjs';
import { informar as informarB } from './consumidor-b.mjs';

const esdeveniments = obtenirCataleg();

console.log('CATALEG');
console.table(esdeveniments.map((e) => ({
  id: e.id,
  titol: e.titol,
  sala: e.sala,
  sessions: e.sessions.length,
  aforament: e.sessions.reduce((t, s) => t + s.aforament, 0),
  venudes: e.sessions.reduce((t, s) => t + s.venudes, 0)
})));

const trobada = obtenirSessio('ses-002-1');
console.log('');
console.log(`Sessio ses-002-1: ${trobada.esdeveniment.titol}, ` +
  `${trobada.sessio.aforament - trobada.sessio.venudes} lliures`);

// Pausa amb await de nivell superior: impossible en CommonJS.
await dormir(50);

// 4. La marca de temps es la MATEIXA als tres moduls.
console.log('');
console.log('MEMORIA CAU DE MODULS EN ESM');
console.table([
  { modul: 'principal', carregatEl: CARREGAT_EL, dada: `${esdeveniments.length} esdeveniments` },
  { ...informarA(), dada: `${informarA().esdeveniments} esdeveniments` },
  { ...informarB(), dada: informarB().titol }
]);

const totesIguals = CARREGAT_EL === informarA().carregatEl && CARREGAT_EL === informarB().carregatEl;
console.log('');
console.log(`Mateixa marca de temps als tres moduls? ${totesIguals}`);

[cataleg] carregats 3 esdeveniments des de /home/joan/escena-viva-esm/dades/esdeveniments.json
CATALEG
┌─────────┬───────────┬─────────────────────────────────┬────────────────────┬──────────┬───────────┬─────────┐
│ (index) │ id        │ titol                           │ sala               │ sessions │ aforament │ venudes │
├─────────┼───────────┼─────────────────────────────────┼────────────────────┼──────────┼───────────┼─────────┤
│ 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    │
└─────────┴───────────┴─────────────────────────────────┴────────────────────┴──────────┴───────────┴─────────┘

Sessio ses-002-1: Noche de Monologos, 2 lliures

MEMORIA CAU DE MODULS EN ESM
┌─────────┬────────────────┬────────────────────────────┬──────────────────────┐
│ (index) │ modul          │ carregatEl                 │ dada                 │
├─────────┼────────────────┼────────────────────────────┼──────────────────────┤
│ 0       │ 'principal'    │ '2026-08-11T18:42:07.331Z' │ '3 esdeveniments'    │
│ 1       │ 'consumidor-a' │ '2026-08-11T18:42:07.331Z' │ '3 esdeveniments'    │
│ 2       │ 'consumidor-b' │ '2026-08-11T18:42:07.331Z' │ 'Noche de Monologos' │
└─────────┴────────────────┴────────────────────────────┴──────────────────────┘

Mateixa marca de temps als tres moduls? true